From alenhar2 at cs.uiuc.edu Mon Jun 20 08:36:45 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Mon, 20 Jun 2005 08:36:45 -0500 Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/LICM.cpp Message-ID: <200506201336.IAA22561@zion.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: LICM.cpp updated: 1.74 -> 1.75 --- Log message: prevent va_arg from being hoisted from a loop --- Diffs of the changes: (+1 -1) LICM.cpp | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-) Index: llvm/lib/Transforms/Scalar/LICM.cpp diff -u llvm/lib/Transforms/Scalar/LICM.cpp:1.74 llvm/lib/Transforms/Scalar/LICM.cpp:1.75 --- llvm/lib/Transforms/Scalar/LICM.cpp:1.74 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Transforms/Scalar/LICM.cpp Mon Jun 20 08:36:33 2005 @@ -386,7 +386,7 @@ return isa(I) || isa(I) || isa(I) || isa(I) || - isa(I) || isa(I); + isa(I); } /// isNotUsedInLoop - Return true if the only users of this instruction are From alenhar2 at cs.uiuc.edu Mon Jun 20 10:02:17 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Mon, 20 Jun 2005 10:02:17 -0500 Subject: [llvm-commits] CVS: llvm/lib/Analysis/LoadValueNumbering.cpp Message-ID: <200506201502.KAA22985@zion.cs.uiuc.edu> Changes in directory llvm/lib/Analysis: LoadValueNumbering.cpp updated: 1.31 -> 1.32 --- Log message: prevent GCSE from forwarding stores to loads around vaarg. This is uggly, and I am trying to fix the AliasInfo, as it should catch the problem instead. --- Diffs of the changes: (+4 -0) LoadValueNumbering.cpp | 4 ++++ 1 files changed, 4 insertions(+) Index: llvm/lib/Analysis/LoadValueNumbering.cpp diff -u llvm/lib/Analysis/LoadValueNumbering.cpp:1.31 llvm/lib/Analysis/LoadValueNumbering.cpp:1.32 --- llvm/lib/Analysis/LoadValueNumbering.cpp:1.31 Thu Apr 21 16:04:58 2005 +++ llvm/lib/Analysis/LoadValueNumbering.cpp Mon Jun 20 10:02:05 2005 @@ -328,6 +328,10 @@ LoadInvalidatedInBBBefore = true; break; } + if (dyn_cast(I)) { + LoadInvalidatedInBBBefore = true; + break; + } } // Figure out if the load is invalidated between the load and the exit of the From alenhar2 at cs.uiuc.edu Mon Jun 20 10:24:35 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Mon, 20 Jun 2005 10:24:35 -0500 Subject: [llvm-commits] CVS: llvm/include/llvm/Analysis/AliasAnalysis.h Message-ID: <200506201524.KAA15079@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/Analysis: AliasAnalysis.h updated: 1.21 -> 1.22 --- Log message: make AliasAnalysis know that VAArg writes memory. This is extremely conservative and should be fixed --- Diffs of the changes: (+5 -0) AliasAnalysis.h | 5 +++++ 1 files changed, 5 insertions(+) Index: llvm/include/llvm/Analysis/AliasAnalysis.h diff -u llvm/include/llvm/Analysis/AliasAnalysis.h:1.21 llvm/include/llvm/Analysis/AliasAnalysis.h:1.22 --- llvm/include/llvm/Analysis/AliasAnalysis.h:1.21 Thu Apr 21 15:16:31 2005 +++ llvm/include/llvm/Analysis/AliasAnalysis.h Mon Jun 20 10:24:23 2005 @@ -37,6 +37,7 @@ class LoadInst; class StoreInst; +class VAArgInst; class TargetData; class AliasAnalysis { @@ -254,8 +255,12 @@ ModRefResult getModRefInfo(InvokeInst *I, Value *P, unsigned Size) { return getModRefInfo(CallSite(I), P, Size); } + ModRefResult getModRefInfo(VAArgInst* I, Value* P, unsigned Size) { + return AliasAnalysis::Mod; + } ModRefResult getModRefInfo(Instruction *I, Value *P, unsigned Size) { switch (I->getOpcode()) { + case Instruction::VAArg: return getModRefInfo((VAArgInst*)I, P, Size); case Instruction::Load: return getModRefInfo((LoadInst*)I, P, Size); case Instruction::Store: return getModRefInfo((StoreInst*)I, P, Size); case Instruction::Call: return getModRefInfo((CallInst*)I, P, Size); From alenhar2 at cs.uiuc.edu Mon Jun 20 10:25:33 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Mon, 20 Jun 2005 10:25:33 -0500 Subject: [llvm-commits] CVS: llvm/lib/Analysis/LoadValueNumbering.cpp Message-ID: <200506201525.KAA15319@zion.cs.uiuc.edu> Changes in directory llvm/lib/Analysis: LoadValueNumbering.cpp updated: 1.32 -> 1.33 --- Log message: the correct fix was to fix AliasAnalysis.getModRefInfo --- Diffs of the changes: (+0 -4) LoadValueNumbering.cpp | 4 ---- 1 files changed, 4 deletions(-) Index: llvm/lib/Analysis/LoadValueNumbering.cpp diff -u llvm/lib/Analysis/LoadValueNumbering.cpp:1.32 llvm/lib/Analysis/LoadValueNumbering.cpp:1.33 --- llvm/lib/Analysis/LoadValueNumbering.cpp:1.32 Mon Jun 20 10:02:05 2005 +++ llvm/lib/Analysis/LoadValueNumbering.cpp Mon Jun 20 10:25:22 2005 @@ -328,10 +328,6 @@ LoadInvalidatedInBBBefore = true; break; } - if (dyn_cast(I)) { - LoadInvalidatedInBBBefore = true; - break; - } } // Figure out if the load is invalidated between the load and the exit of the From alenhar2 at cs.uiuc.edu Mon Jun 20 10:41:49 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Mon, 20 Jun 2005 10:41:49 -0500 Subject: [llvm-commits] CVS: llvm/lib/AsmParser/llvmAsmParser.y Message-ID: <200506201541.KAA18379@zion.cs.uiuc.edu> Changes in directory llvm/lib/AsmParser: llvmAsmParser.y updated: 1.228 -> 1.229 --- Log message: because some functions just use va_start and pass things to vfprintf --- Diffs of the changes: (+11 -0) llvmAsmParser.y | 11 +++++++++++ 1 files changed, 11 insertions(+) Index: llvm/lib/AsmParser/llvmAsmParser.y diff -u llvm/lib/AsmParser/llvmAsmParser.y:1.228 llvm/lib/AsmParser/llvmAsmParser.y:1.229 --- llvm/lib/AsmParser/llvmAsmParser.y:1.228 Sun Jun 19 09:04:55 2005 +++ llvm/lib/AsmParser/llvmAsmParser.y Mon Jun 20 10:41:37 2005 @@ -737,6 +737,17 @@ Module *Result = ParserResult; ParserResult = 0; + //Not all functions use vaarg, so make a second check for ObsoleteVarArgs + { + Function* F; + if ((F = Result->getNamedFunction("llvm.va_start")) + && F->getFunctionType()->getNumParams() == 0) + ObsoleteVarArgs = true; + if((F = Result->getNamedFunction("llvm.va_copy")) + && F->getFunctionType()->getNumParams() == 1) + ObsoleteVarArgs = true; + } + if (ObsoleteVarArgs && NewVarArgs) { std::cerr << "This file is corrupt in that it uses both new and old style varargs\n"; From criswell at cs.uiuc.edu Mon Jun 20 14:59:39 2005 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon, 20 Jun 2005 14:59:39 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86AsmPrinter.cpp Message-ID: <200506201959.OAA26957@choi.cs.uiuc.edu> Changes in directory llvm/lib/Target/X86: X86AsmPrinter.cpp updated: 1.136 -> 1.137 --- Log message: Fixed indentation. --- Diffs of the changes: (+3 -3) X86AsmPrinter.cpp | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-) Index: llvm/lib/Target/X86/X86AsmPrinter.cpp diff -u llvm/lib/Target/X86/X86AsmPrinter.cpp:1.136 llvm/lib/Target/X86/X86AsmPrinter.cpp:1.137 --- llvm/lib/Target/X86/X86AsmPrinter.cpp:1.136 Thu Apr 21 18:38:14 2005 +++ llvm/lib/Target/X86/X86AsmPrinter.cpp Mon Jun 20 14:59:22 2005 @@ -173,9 +173,9 @@ } emitAlignment(Align); - if (!forCygwin) { - O << "\t.type " << name << ", at object\n"; - O << "\t.size " << name << "," << Size << "\n"; + if (!forCygwin) { + O << "\t.type " << name << ", at object\n"; + O << "\t.size " << name << "," << Size << "\n"; } O << name << ":\t\t\t\t# "; WriteAsOperand(O, I, true, true, &M); From llvm at cs.uiuc.edu Wed Jun 22 01:30:08 2005 From: llvm at cs.uiuc.edu (LLVM) Date: Wed, 22 Jun 2005 01:30:08 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/ Message-ID: <200506220630.BAA03989@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF: --- Log message: Directory /var/cvs/llvm/llvm/lib/CodeGen/ELF added to the repository --- Diffs of the changes: (+0 -0) 0 files changed From llvm at cs.uiuc.edu Wed Jun 22 01:30:42 2005 From: llvm at cs.uiuc.edu (LLVM) Date: Wed, 22 Jun 2005 01:30:42 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/lib/ Message-ID: <200506220630.BAA04000@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF/lib: --- Log message: Directory /var/cvs/llvm/llvm/lib/CodeGen/ELF/lib added to the repository --- Diffs of the changes: (+0 -0) 0 files changed From llvm at cs.uiuc.edu Wed Jun 22 01:30:42 2005 From: llvm at cs.uiuc.edu (LLVM) Date: Wed, 22 Jun 2005 01:30:42 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/po/ Message-ID: <200506220630.BAA04004@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF/po: --- Log message: Directory /var/cvs/llvm/llvm/lib/CodeGen/ELF/po added to the repository --- Diffs of the changes: (+0 -0) 0 files changed From reid at x10sys.com Wed Jun 22 01:36:10 2005 From: reid at x10sys.com (Reid Spencer) Date: Wed, 22 Jun 2005 01:36:10 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/po/Makefile.in de.gmo de.msg de.po gmo2msg.c libelf.pot stamp-po Message-ID: <200506220636.BAA04120@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF/po: Makefile.in added (r1.1) de.gmo added (r1.1) de.msg added (r1.1) de.po added (r1.1) gmo2msg.c added (r1.1) libelf.pot added (r1.1) stamp-po added (r1.1) --- Log message: Adding libELF 0.8.5. This is the first baby step towards supporting direct generation of ELF files in LLVM. Its not clear at this point that all of the software added by this commit is actually needed. However, until requirements are solidified, I've included the whole thing. Note that this currently won't be built by the makefile system. Once an LLVM interface to this software is available, we'll start building libELF in order to provide the functionality. --- Diffs of the changes: (+1135 -0) Makefile.in | 184 ++++++++++++++++++++++++++++++++++ de.gmo | 0 de.msg | 228 ++++++++++++++++++++++++++++++++++++++++++ de.po | 322 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ gmo2msg.c | 97 ++++++++++++++++++ libelf.pot | 303 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ stamp-po | 1 7 files changed, 1135 insertions(+) Index: llvm/lib/CodeGen/ELF/po/Makefile.in diff -c /dev/null llvm/lib/CodeGen/ELF/po/Makefile.in:1.1 *** /dev/null Wed Jun 22 01:36:07 2005 --- llvm/lib/CodeGen/ELF/po/Makefile.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,184 ---- + # po/Makefile for libelf. + # Copyright (C) 1995 - 2001 Michael Riepe + # + # This library is free software; you can redistribute it and/or + # modify it under the terms of the GNU Library General Public + # License as published by the Free Software Foundation; either + # version 2 of the License, or (at your option) any later version. + # + # This library 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 + # Library General Public License for more details. + # + # You should have received a copy of the GNU Library General Public + # License along with this library; if not, write to the Free Software + # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + # @(#) $Id: Makefile.in,v 1.1 2005/06/22 06:35:57 reid Exp $ + + instroot = + + prefix = @prefix@ + exec_prefix = @exec_prefix@ + localedir = @localedir@ + + CC = @CC@ + RM = rm -f + MV = mv -f + INSTALL = @INSTALL@ + INSTALL_DATA = @INSTALL_DATA@ + + GENCAT = @GENCAT@ + GMSGFMT = @GMSGFMT@ + MSGFMT = @MSGFMT@ + XGETTEXT = @XGETTEXT@ + TUPDATE = tupdate + + CFLAGS = @CFLAGS@ + CPPFLAGS = @CPPFLAGS@ + DEFS = -DHAVE_CONFIG_H + LDFLAGS = @LDFLAGS@ + LIBS = @LIBS@ + + # no user serviceable parts below + + PACKAGE = @PACKAGE@ + VERSION = @VERSION@ + + SHELL = /bin/sh + @SET_MAKE@ + + srcdir = @srcdir@ + top_srcdir = @top_srcdir@ + VPATH = @srcdir@ + + topdir = .. + subdir = po + + .SUFFIXES: + .SUFFIXES: .po .mo .gmo .msg .cat + + .po.mo: + @$(RM) $@ + $(MSGFMT) -o $@ $< + + .po.gmo: + file=$(srcdir)/`echo $*|sed 's,.*/,,'`.gmo; \ + $(RM) $$file && $(GMSGFMT) -o $$file $< + + .msg.cat: + @$(RM) $@ + $(GENCAT) $@ $< + + POFILES = @POFILES@ + GMOFILES = @GMOFILES@ + MSGFILES = @MSGFILES@ + + DISTFILES = \ + gmo2msg.c Makefile.in $(PACKAGE).pot stamp-po \ + $(POFILES) $(GMOFILES) $(MSGFILES) + + POTFILES = $(top_srcdir)/lib/errors.h + + CATALOGS = @CATALOGS@ + CATOBJEXT = @CATOBJEXT@ + INSTOBJEXT = @INSTOBJEXT@ + + all: $(CATALOGS) + + check: + + install: all install-data + + install-data: $(top_srcdir)/mkinstalldirs + catalogs="$(CATALOGS)"; for cat in $$catalogs; do \ + lang=`echo $$cat | sed 's,$(CATOBJEXT)$$,,'`; \ + dir=$(localedir)/$$lang/LC_MESSAGES; \ + $(SHELL) $(top_srcdir)/mkinstalldirs $(instroot)$$dir; \ + if test -r $$cat; then \ + $(INSTALL_DATA) $$cat $(instroot)$$dir/$(PACKAGE)$(INSTOBJEXT); \ + else \ + $(INSTALL_DATA) $(srcdir)/$$cat $(instroot)$$dir/$(PACKAGE)$(INSTOBJEXT); \ + fi; \ + done + + uninstall: + catalogs="$(CATALOGS)"; for cat in $$catalogs; do \ + lang=`echo $$cat | sed 's,$(CATOBJEXT)$$,,'`; \ + $(RM) $(instroot)$(localedir)/$$lang/LC_MESSAGES/$(PACKAGE)$(INSTOBJEXT); \ + done + + mostlyclean: + $(RM) core core.* $(PACKAGE).po *.po.tmp + + clean: mostlyclean + + distclean: clean + $(RM) gmo2msg *.mo *.cat + $(RM) Makefile + + maintainer-clean: distclean + $(RM) stamp-po + + $(PACKAGE).pot: $(POTFILES) + $(XGETTEXT) -c -d$(PACKAGE) -k_ $(POTFILES) + if cmp -s $(PACKAGE).po $(srcdir)/$(PACKAGE).pot; then \ + $(RM) $(PACKAGE).po; \ + else \ + $(RM) $(srcdir)/$(PACKAGE).pot && \ + $(MV) $(PACKAGE).po $(srcdir)/$(PACKAGE).pot; \ + fi + + update-po: stamp-po + stamp-po: $(PACKAGE).pot + pofiles="$(POFILES)"; cd $(srcdir) && for po in $$pofiles; do \ + $(RM) $$po.tmp; \ + if $(TUPDATE) $(PACKAGE).pot $$po > $$po.tmp; then \ + $(RM) $$po; \ + $(MV) $$po.tmp $$po; \ + else \ + echo "tupdate for $$po failed!"; \ + $(RM) $$po.tmp; \ + fi; \ + done + $(RM) $@ && echo timestamp > $@ + + # Create X/Open message catalog sources from .gmo files. + + .gmo.msg: + $(MAKE) $(srcdir)/gmo2msg + LANGUAGE=`echo $*|sed 's,.*/,,'`; export LANGUAGE; \ + cd $(srcdir) && $(RM) $$LANGUAGE.msg && ./gmo2msg > $$LANGUAGE.msg + + .SUFFIXES: .c + + .c: + @$(RM) $@ + $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(XCFLAGS) \ + $(LDFLAGS) $*.c $(LIBS) -lintl -o $@ + + INCLUDES = -I$(topdir) -I. -I$(topdir)/lib -I$(srcdir) -I$(top_srcdir)/lib + + # maintainer only + + MAINT = @MAINT@ + + distdir = $(PACKAGE)-$(VERSION) + distsubdir = $(topdir)/$(distdir)/$(subdir) + $(MAINT)dist: update-po $(DISTFILES) + if test -d $(distsubdir); then true; else mkdir $(distsubdir); fi + files="$(DISTFILES)"; for file in $$files; do \ + ln $(srcdir)/$$file $(distsubdir) >/dev/null 2>&1 || \ + cp -p $(srcdir)/$$file $(distsubdir) || exit 1; \ + done + + # For the justification of the following Makefile rules, see node + # `Automatic Remaking' in GNU Autoconf documentation. + + $(MAINT)Makefile: Makefile.in $(topdir)/config.status + cd $(topdir) && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status + + # Tell versions [3.59,3.63) of GNU make not to export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. + .NOEXPORT: Index: llvm/lib/CodeGen/ELF/po/de.gmo Index: llvm/lib/CodeGen/ELF/po/de.msg diff -c /dev/null llvm/lib/CodeGen/ELF/po/de.msg:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/po/de.msg Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,228 ---- + $set 1 Automatically created from de.gmo by gmo2msg + $ Date: 2001-10-06 20:40:10+0200 + $ From: Michael Riepe + $ Content-Type: text/plain; charset=iso-8859-1 + $ Xgettext-Options: -c -dlibelf -k_ + $ Files: ../lib/errors.h + $ + $ Original message: no error + 1 Kein Fehler + $ + $ Original message: unknown error + 2 Unbekannter Fehler + $ + $ Original message: Internal error: unknown reason + 3 Interner Fehler: Ursache unbekannt + $ + $ Original message: Internal error: not implemented + 4 Interner Fehler: Diese Funktion ist nicht implementiert + $ + $ Original message: Request error: cntl(ELF_C_FDREAD) on write-only file + 5 Aufruffehler: cntl(ELF_C_FDREAD) ohne Leseberechtigung + $ + $ Original message: Request error: invalid ELF_C_* argument + 6 Aufruffehler: Das ELF_C_*-Argument ist ung?ltig + $ + $ Original message: Request error: file descriptor disabled + 7 Aufruffehler: Der Zugriff auf diese Datei ist nicht mehr m?glich + $ + $ Original message: Request error: not an archive + 8 Aufruffehler: Die bearbeitete Datei ist kein Archiv (.a) + $ + $ Original message: Request error: offset out of range + 9 Aufruffehler: Die gew?nschte Byteposition liegt au?erhalb der Datei + $ + $ Original message: Request error: unknown ELF version + 10 Aufruffehler: unbekannte ELF-Version + $ + $ Original message: Request error: ELF_C_* argument does not match + 11 Aufruffehler: Das ELF_C_*-Argument pa?t nicht zu den Zugriffsrechten + $ + $ Original message: Request error: archive member begin() for writing + 12 Aufruffehler: Der Archivinhalt ist nicht schreibbar + $ + $ Original message: Request error: archive/member file descriptor mismatch + 13 Aufruffehler: Die Datei- und Archiv-Deskriptoren passen nicht zusammen + $ + $ Original message: Request error: not an ELF file + 14 Aufruffehler: Dies ist keine ELF-Datei + $ + $ Original message: Request error: class file/memory mismatch + 15 Aufruffehler: Die Datei geh?rt zur falschen ELF-Klasse (32/64 Bit) + $ + $ Original message: Request error: invalid ELF_T_* argument + 16 Aufruffehler: Das ELF_T_*-Argument ist ung?ltig + $ + $ Original message: Request error: unknown data encoding + 17 Aufruffehler: unbekannte Datenrepr?sentation (big/little endian) + $ + $ Original message: Request error: destination buffer too small + 18 Aufruffehler: Der Zielpuffer ist zu klein + $ + $ Original message: Request error: d_buf is NULL + 19 Aufruffehler: d_buf ist NULL + $ + $ Original message: Request error: unknown ELF class + 20 Aufruffehler: unbekannte ELF-Klasse (32/64 Bit) + $ + $ Original message: Request error: section does not belong to file + 21 Aufruffehler: Der Dateiabschnitt geh?rt nicht zu dieser Datei + $ + $ Original message: Request error: no section at index + 22 Aufruffehler: Ein Abschnitt mit dieser Nummer existiert nicht + $ + $ Original message: Request error: can't manipulate null section + 23 Aufruffehler: Sie versuchen, den "Null"-Abschnitt zu bearbeiten + $ + $ Original message: Request error: data does not belong to section + 24 Aufruffehler: Dieser Datenblock geh?rt nicht zum angegebenen Dateiabschnitt + $ + $ Original message: Request error: no string table + 25 Aufruffehler: Die Namenliste fehlt + $ + $ Original message: Request error: string table offset out of range + 26 Aufruffehler: Die gew?nschte Position liegt au?erhalb der Namenliste + $ + $ Original message: Request error: update(ELF_C_WRITE) on read-only file + 27 Aufruffehler: update(ELF_C_WRITE) ohne Schreibberechtigung + $ + $ Original message: I/O error: seek + 28 Ein-/Ausgabefehler: Das Positionieren innerhalb der Datei schlug fehl + $ + $ Original message: I/O error: file too big for memory + 29 Ein-/Ausgabefehler: Die Datei ist zu gro? + $ + $ Original message: I/O error: raw read + 30 Ein-/Ausgabefehler: Lesefehler + $ + $ Original message: I/O error: get file size + 31 Ein-/Ausgabefehler: Die Dateigr??e ist nicht zu ermitteln + $ + $ Original message: I/O error: output write + 32 Ein-/Ausgabefehler: Schreibfehler + $ + $ Original message: I/O error: can't truncate output file + 33 Ein-/Ausgabefehler: Das Verk?rzen der Datei schlug fehl + $ + $ Original message: Sequence error: must set ELF version first + 34 Falsche Reihenfolge: Sie m?ssen zuerst elf_version() aufrufen + $ + $ Original message: Sequence error: must create ELF header first + 35 Falsche Reihenfolge: Sie m?ssen zuerst elf{32,64}_newehdr() aufrufen + $ + $ Original message: Format error: reference outside file + 36 Fehler in der Datei: Eine Positionsangabe zeigt auf einen Punkt au?erhalb der Datei + $ + $ Original message: Format error: archive header truncated + 37 Fehler in der Datei: Der Archiv-Header ist unvollst?ndig + $ + $ Original message: Format error: archive fmag + 38 Fehler in der Datei: Die Archiv-Kennung ist falsch + $ + $ Original message: Format error: archive header + 39 Fehler in der Datei: Der Archiv-Header ist fehlerhaft + $ + $ Original message: Format error: archive member truncated + 40 Fehler in der Datei: Der Archivinhalt ist unvollst?ndig + $ + $ Original message: Format error: archive symbol table size + 41 Fehler in der Datei: Die Gr??e der Archiv-Symboltabelle ist falsch + $ + $ Original message: Format error: archive string table + 42 Fehler in der Datei: Die Archiv-Namenliste ist defekt + $ + $ Original message: Format error: archive special name unknown + 43 Fehler in der Datei: Es existiert ein internes Archiv-Objekt mit unbekanntem Namen + $ + $ Original message: Format error: ELF header truncated + 44 Fehler in der Datei: Der ELF-Header ist unvollst?ndig + $ + $ Original message: Format error: program header table truncated + 45 Fehler in der Datei: Die ELF Program Header Table ist unvollst?ndig + $ + $ Original message: Format error: section header table truncated + 46 Fehler in der Datei: Die ELF Section Header Table ist unvollst?ndig + $ + $ Original message: Format error: data region truncated + 47 Fehler in der Datei: Ein Datenblock ist unvollst?ndig + $ + $ Original message: Format error: program header table alignment + 48 Fehler in der Datei: Die ELF Program Header Table liegt nicht auf einer Wortgrenze + $ + $ Original message: Format error: section header table alignment + 49 Fehler in der Datei: Die ELF Section Header Table liegt nicht auf einer Wortgrenze + $ + $ Original message: Format error: bad parameter in Verdef record + 50 Fehler in der Datei: Verdef-Datensatz enth?lt ung?ltige Parameter + $ + $ Original message: Format error: unknown Verdef version + 51 Fehler in der Datei: libelf unterst?tzt die Verdef-Version nicht + $ + $ Original message: Format error: bad parameter in Verneed record + 52 Fehler in der Datei: Verneed-Datensatz enth?lt ung?ltige Parameter + $ + $ Original message: Format error: unknown Verneed version + 53 Fehler in der Datei: libelf unterst?tzt die Verneed-Version nicht + $ + $ Original message: Format error: bad e_shnum value + 54 Fehler in der Datei: e_shnum enth?lt einen ung?ltigen Wert + $ + $ Original message: Format error: unterminated string in string table + 55 Fehler in der Datei: Der Eintrag in der String-Tabelle ist nicht terminiert + $ + $ Original message: Layout error: section size too small for data + 56 Layout-Fehler: Ein Dateiabschnitt ist zu kurz f?r die darin enthaltenen Daten + $ + $ Original message: Layout error: overlapping sections + 57 Layout-Fehler: Zwei (oder mehr) Dateiabschnitte ?berlappen sich + $ + $ Original message: Memory error: elf descriptor + 58 Zu wenig Speicher: f?r den Elf-Deskriptor + $ + $ Original message: Memory error: archive symbol table + 59 Zu wenig Speicher: f?r die Archiv-Symboltabelle + $ + $ Original message: Memory error: archive member header + 60 Zu wenig Speicher: f?r die Archiv-Verwaltungsinformationen + $ + $ Original message: Memory error: ELF header + 61 Zu wenig Speicher: f?r den ELF-Header + $ + $ Original message: Memory error: program header table + 62 Zu wenig Speicher: f?r die Program Header Table + $ + $ Original message: Memory error: section header table + 63 Zu wenig Speicher: f?r die Section Header Table + $ + $ Original message: Memory error: section descriptor + 64 Zu wenig Speicher: f?r den Elf_Scn-Deskriptor + $ + $ Original message: Memory error: section data + 65 Zu wenig Speicher: f?r die Daten dieses Abschnitts + $ + $ Original message: Memory error: output file space + 66 Zu wenig Speicher: f?r die Ausgabe + $ + $ Original message: Memory error: temporary buffer + 67 Zu wenig Speicher: f?r einen tempor?ren Puffer + $ + $ Original message: GElf error: value out of range + 68 GElf-Fehler: eine Zahl ist au?erhalb des darstellbaren Bereichs + $ + $ Original message: GElf error: index out of range + 69 GElf-Fehler: Index au?erhalb des erlaubten Bereichs + $ + $ Original message: GElf error: type mismatch + 70 GElf-Fehler: Typfehler + $ + $ Original message: GElf error: not enough memory for GElf_Sym + 71 GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Sym + $ + $ Original message: GElf error: not enough memory for GElf_Dyn + 72 GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Dyn + $ + $ Original message: GElf error: not enough memory for GElf_Rela + 73 GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Rela + $ + $ Original message: GElf error: not enough memory for GElf_Rel + 74 GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Rel Index: llvm/lib/CodeGen/ELF/po/de.po diff -c /dev/null llvm/lib/CodeGen/ELF/po/de.po:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/po/de.po Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,322 ---- + # po/de.po - German messages for libelf. + # Copyright (C) 1999 - 2003 Michael Riepe + # + # This library is free software; you can redistribute it and/or + # modify it under the terms of the GNU Library General Public + # License as published by the Free Software Foundation; either + # version 2 of the License, or (at your option) any later version. + # + # This library 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 + # Library General Public License for more details. + # + # You should have received a copy of the GNU Library General Public + # License along with this library; if not, write to the Free Software + # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + # + # @(#) $Id: de.po,v 1.1 2005/06/22 06:35:57 reid Exp $ + # + msgid "" + msgstr "" + "Date: 2001-10-06 20:40:10+0200\n" + "From: Michael Riepe \n" + "Content-Type: text/plain; charset=iso-8859-1\n" + "Xgettext-Options: -c -dlibelf -k_\n" + "Files: ../lib/errors.h\n" + + #: ../lib/errors.h:25 + msgid "no error" + msgstr "Kein Fehler" + + #: ../lib/errors.h:26 + msgid "unknown error" + msgstr "Unbekannter Fehler" + + #: ../lib/errors.h:27 + msgid "Internal error: unknown reason" + msgstr "Interner Fehler: Ursache unbekannt" + + #: ../lib/errors.h:28 + msgid "Internal error: not implemented" + msgstr "Interner Fehler: Diese Funktion ist nicht implementiert" + + #: ../lib/errors.h:29 + msgid "Request error: cntl(ELF_C_FDREAD) on write-only file" + msgstr "Aufruffehler: cntl(ELF_C_FDREAD) ohne Leseberechtigung" + + #: ../lib/errors.h:30 + msgid "Request error: invalid ELF_C_* argument" + msgstr "Aufruffehler: Das ELF_C_*-Argument ist ung?ltig" + + #: ../lib/errors.h:31 + msgid "Request error: file descriptor disabled" + msgstr "Aufruffehler: Der Zugriff auf diese Datei ist nicht mehr m?glich" + + #: ../lib/errors.h:32 + msgid "Request error: not an archive" + msgstr "Aufruffehler: Die bearbeitete Datei ist kein Archiv (.a)" + + #: ../lib/errors.h:33 + msgid "Request error: offset out of range" + msgstr "Aufruffehler: Die gew?nschte Byteposition liegt au?erhalb der Datei" + + #: ../lib/errors.h:34 + msgid "Request error: unknown ELF version" + msgstr "Aufruffehler: unbekannte ELF-Version" + + #: ../lib/errors.h:35 + msgid "Request error: ELF_C_* argument does not match" + msgstr "Aufruffehler: Das ELF_C_*-Argument pa?t nicht zu den Zugriffsrechten" + + #: ../lib/errors.h:36 + msgid "Request error: archive member begin() for writing" + msgstr "Aufruffehler: Der Archivinhalt ist nicht schreibbar" + + #: ../lib/errors.h:37 + msgid "Request error: archive/member file descriptor mismatch" + msgstr "Aufruffehler: Die Datei- und Archiv-Deskriptoren passen nicht zusammen" + + #: ../lib/errors.h:38 + msgid "Request error: not an ELF file" + msgstr "Aufruffehler: Dies ist keine ELF-Datei" + + #: ../lib/errors.h:39 + msgid "Request error: class file/memory mismatch" + msgstr "Aufruffehler: Die Datei geh?rt zur falschen ELF-Klasse (32/64 Bit)" + + #: ../lib/errors.h:40 + msgid "Request error: invalid ELF_T_* argument" + msgstr "Aufruffehler: Das ELF_T_*-Argument ist ung?ltig" + + #: ../lib/errors.h:41 + msgid "Request error: unknown data encoding" + msgstr "Aufruffehler: unbekannte Datenrepr?sentation (big/little endian)" + + #: ../lib/errors.h:42 + msgid "Request error: destination buffer too small" + msgstr "Aufruffehler: Der Zielpuffer ist zu klein" + + #: ../lib/errors.h:43 + msgid "Request error: d_buf is NULL" + msgstr "Aufruffehler: d_buf ist NULL" + + #: ../lib/errors.h:44 + msgid "Request error: unknown ELF class" + msgstr "Aufruffehler: unbekannte ELF-Klasse (32/64 Bit)" + + #: ../lib/errors.h:45 + msgid "Request error: section does not belong to file" + msgstr "Aufruffehler: Der Dateiabschnitt geh?rt nicht zu dieser Datei" + + #: ../lib/errors.h:46 + msgid "Request error: no section at index" + msgstr "Aufruffehler: Ein Abschnitt mit dieser Nummer existiert nicht" + + #: ../lib/errors.h:47 + msgid "Request error: can't manipulate null section" + msgstr "Aufruffehler: Sie versuchen, den \"Null\"-Abschnitt zu bearbeiten" + + #: ../lib/errors.h:48 + msgid "Request error: data does not belong to section" + msgstr "Aufruffehler: Dieser Datenblock geh?rt nicht zum angegebenen Dateiabschnitt" + + #: ../lib/errors.h:49 + msgid "Request error: no string table" + msgstr "Aufruffehler: Die Namenliste fehlt" + + #: ../lib/errors.h:50 + msgid "Request error: string table offset out of range" + msgstr "Aufruffehler: Die gew?nschte Position liegt au?erhalb der Namenliste" + + #: ../lib/errors.h:51 + msgid "Request error: update(ELF_C_WRITE) on read-only file" + msgstr "Aufruffehler: update(ELF_C_WRITE) ohne Schreibberechtigung" + + #: ../lib/errors.h:52 + msgid "I/O error: seek" + msgstr "Ein-/Ausgabefehler: Das Positionieren innerhalb der Datei schlug fehl" + + #: ../lib/errors.h:53 + msgid "I/O error: file too big for memory" + msgstr "Ein-/Ausgabefehler: Die Datei ist zu gro?" + + #: ../lib/errors.h:54 + msgid "I/O error: raw read" + msgstr "Ein-/Ausgabefehler: Lesefehler" + + #: ../lib/errors.h:55 + msgid "I/O error: get file size" + msgstr "Ein-/Ausgabefehler: Die Dateigr??e ist nicht zu ermitteln" + + #: ../lib/errors.h:56 + msgid "I/O error: output write" + msgstr "Ein-/Ausgabefehler: Schreibfehler" + + #: ../lib/errors.h:57 + msgid "I/O error: can't truncate output file" + msgstr "Ein-/Ausgabefehler: Das Verk?rzen der Datei schlug fehl" + + #: ../lib/errors.h:58 + msgid "Sequence error: must set ELF version first" + msgstr "Falsche Reihenfolge: Sie m?ssen zuerst elf_version() aufrufen" + + #: ../lib/errors.h:59 + msgid "Sequence error: must create ELF header first" + msgstr "Falsche Reihenfolge: Sie m?ssen zuerst elf{32,64}_newehdr() aufrufen" + + #: ../lib/errors.h:60 + msgid "Format error: reference outside file" + msgstr "Fehler in der Datei: Eine Positionsangabe zeigt auf einen Punkt au?erhalb der Datei" + + #: ../lib/errors.h:61 + msgid "Format error: archive header truncated" + msgstr "Fehler in der Datei: Der Archiv-Header ist unvollst?ndig" + + #: ../lib/errors.h:62 + msgid "Format error: archive fmag" + msgstr "Fehler in der Datei: Die Archiv-Kennung ist falsch" + + #: ../lib/errors.h:63 + msgid "Format error: archive header" + msgstr "Fehler in der Datei: Der Archiv-Header ist fehlerhaft" + + #: ../lib/errors.h:64 + msgid "Format error: archive member truncated" + msgstr "Fehler in der Datei: Der Archivinhalt ist unvollst?ndig" + + #: ../lib/errors.h:65 + msgid "Format error: archive symbol table size" + msgstr "Fehler in der Datei: Die Gr??e der Archiv-Symboltabelle ist falsch" + + #: ../lib/errors.h:66 + msgid "Format error: archive string table" + msgstr "Fehler in der Datei: Die Archiv-Namenliste ist defekt" + + #: ../lib/errors.h:67 + msgid "Format error: archive special name unknown" + msgstr "Fehler in der Datei: Es existiert ein internes Archiv-Objekt mit unbekanntem Namen" + + #: ../lib/errors.h:68 + msgid "Format error: ELF header truncated" + msgstr "Fehler in der Datei: Der ELF-Header ist unvollst?ndig" + + #: ../lib/errors.h:69 + msgid "Format error: program header table truncated" + msgstr "Fehler in der Datei: Die ELF Program Header Table ist unvollst?ndig" + + #: ../lib/errors.h:70 + msgid "Format error: section header table truncated" + msgstr "Fehler in der Datei: Die ELF Section Header Table ist unvollst?ndig" + + #: ../lib/errors.h:71 + msgid "Format error: data region truncated" + msgstr "Fehler in der Datei: Ein Datenblock ist unvollst?ndig" + + #: ../lib/errors.h:72 + msgid "Format error: program header table alignment" + msgstr "Fehler in der Datei: Die ELF Program Header Table liegt nicht auf einer Wortgrenze" + + #: ../lib/errors.h:73 + msgid "Format error: section header table alignment" + msgstr "Fehler in der Datei: Die ELF Section Header Table liegt nicht auf einer Wortgrenze" + + #: ../lib/errors.h:74 + msgid "Format error: bad parameter in Verdef record" + msgstr "Fehler in der Datei: Verdef-Datensatz enth?lt ung?ltige Parameter" + + #: ../lib/errors.h:75 + msgid "Format error: unknown Verdef version" + msgstr "Fehler in der Datei: libelf unterst?tzt die Verdef-Version nicht" + + #: ../lib/errors.h:76 + msgid "Format error: bad parameter in Verneed record" + msgstr "Fehler in der Datei: Verneed-Datensatz enth?lt ung?ltige Parameter" + + #: ../lib/errors.h:77 + msgid "Format error: unknown Verneed version" + msgstr "Fehler in der Datei: libelf unterst?tzt die Verneed-Version nicht" + + #: ../lib/errors.h:78 + msgid "Format error: bad e_shnum value" + msgstr "Fehler in der Datei: e_shnum enth?lt einen ung?ltigen Wert" + + #: ../lib/errors.h:79 + msgid "Format error: unterminated string in string table" + msgstr "Fehler in der Datei: Der Eintrag in der String-Tabelle ist nicht terminiert" + + #: ../lib/errors.h:80 + msgid "Layout error: section size too small for data" + msgstr "Layout-Fehler: Ein Dateiabschnitt ist zu kurz f?r die darin enthaltenen Daten" + + #: ../lib/errors.h:81 + msgid "Layout error: overlapping sections" + msgstr "Layout-Fehler: Zwei (oder mehr) Dateiabschnitte ?berlappen sich" + + #: ../lib/errors.h:82 + msgid "Memory error: elf descriptor" + msgstr "Zu wenig Speicher: f?r den Elf-Deskriptor" + + #: ../lib/errors.h:83 + msgid "Memory error: archive symbol table" + msgstr "Zu wenig Speicher: f?r die Archiv-Symboltabelle" + + #: ../lib/errors.h:84 + msgid "Memory error: archive member header" + msgstr "Zu wenig Speicher: f?r die Archiv-Verwaltungsinformationen" + + #: ../lib/errors.h:85 + msgid "Memory error: ELF header" + msgstr "Zu wenig Speicher: f?r den ELF-Header" + + #: ../lib/errors.h:86 + msgid "Memory error: program header table" + msgstr "Zu wenig Speicher: f?r die Program Header Table" + + #: ../lib/errors.h:87 + msgid "Memory error: section header table" + msgstr "Zu wenig Speicher: f?r die Section Header Table" + + #: ../lib/errors.h:88 + msgid "Memory error: section descriptor" + msgstr "Zu wenig Speicher: f?r den Elf_Scn-Deskriptor" + + #: ../lib/errors.h:89 + msgid "Memory error: section data" + msgstr "Zu wenig Speicher: f?r die Daten dieses Abschnitts" + + #: ../lib/errors.h:90 + msgid "Memory error: output file space" + msgstr "Zu wenig Speicher: f?r die Ausgabe" + + #: ../lib/errors.h:91 + msgid "Memory error: temporary buffer" + msgstr "Zu wenig Speicher: f?r einen tempor?ren Puffer" + + #: ../lib/errors.h:92 + msgid "GElf error: value out of range" + msgstr "GElf-Fehler: eine Zahl ist au?erhalb des darstellbaren Bereichs" + + #: ../lib/errors.h:93 + msgid "GElf error: index out of range" + msgstr "GElf-Fehler: Index au?erhalb des erlaubten Bereichs" + + #: ../lib/errors.h:94 + msgid "GElf error: type mismatch" + msgstr "GElf-Fehler: Typfehler" + + #: ../lib/errors.h:95 + msgid "GElf error: not enough memory for GElf_Sym" + msgstr "GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Sym" + + #: ../lib/errors.h:96 + msgid "GElf error: not enough memory for GElf_Dyn" + msgstr "GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Dyn" + + #: ../lib/errors.h:97 + msgid "GElf error: not enough memory for GElf_Rela" + msgstr "GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Rela" + + #: ../lib/errors.h:98 + msgid "GElf error: not enough memory for GElf_Rel" + msgstr "GElf-Fehler: zu wenig Speicher f?r eine Variable vom Typ GElf_Rel" Index: llvm/lib/CodeGen/ELF/po/gmo2msg.c diff -c /dev/null llvm/lib/CodeGen/ELF/po/gmo2msg.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/po/gmo2msg.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,97 ---- + /* + gmo2msg.c - create X/Open message source file for libelf. + Copyright (C) 1996 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #ifndef lint + static const char rcsid[] = "@(#) $Id: gmo2msg.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #include + #include + #include + #include + #include + + #define DOMAIN "libelf" + + static const char *msgs[] = { + #define __err__(a,b) b, + #include + #undef __err__ + }; + + int + main(int argc, char **argv) { + char buf[1024], *lang, *progname, *s; + unsigned i; + + if (*argv && (progname = strrchr(argv[0], '/'))) { + progname++; + } + else if (!(progname = *argv)) { + progname = "gmo2msg"; + } + + if (!(lang = getenv("LANGUAGE")) + && !(lang = getenv("LC_ALL")) + && !(lang = getenv("LC_MESSAGES")) + && !(lang = getenv("LANG"))) { + fprintf(stderr, "LANG variable not set.\n"); + exit(1); + } + + /* + * Fool gettext... + */ + getcwd(buf, sizeof(buf)); + bindtextdomain(DOMAIN, buf); + sprintf(buf, "%s.gmo", lang); + unlink(DOMAIN ".mo"); symlink(buf, DOMAIN ".mo"); + unlink("LC_MESSAGES"); symlink(".", "LC_MESSAGES"); + unlink(lang); symlink(".", lang); + printf("$set 1 Automatically created from %s by %s\n", buf, progname); + + /* + * Get translated messages. + * Assume that messages contain printable ASCII characters ONLY. + * That means no tabs, linefeeds etc. + */ + textdomain(DOMAIN); + if ((s = gettext("")) && (s = strdup(s))) { + s = strtok(s, "\n"); + while (s) { + printf("$ %s\n", s); + s = strtok(NULL, "\n"); + } + } + for (i = 0; i < sizeof(msgs)/sizeof(*msgs); i++) { + s = gettext(msgs[i]); + if (s != msgs[i] && strcmp(s, msgs[i])) { + printf("$ \n$ Original message: %s\n", msgs[i]); + printf("%u %s\n", i + 1, s); + } + } + + /* + * Cleanup. + */ + unlink(DOMAIN ".mo"); + unlink("LC_MESSAGES"); + unlink(lang); + exit(0); + } Index: llvm/lib/CodeGen/ELF/po/libelf.pot diff -c /dev/null llvm/lib/CodeGen/ELF/po/libelf.pot:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/po/libelf.pot Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,303 ---- + msgid "" + msgstr "" + "Date: 2003-05-18 17:03:19+0200\n" + "From: Michael Riepe \n" + "Content-Type: text/plain; charset=\n" + "Xgettext-Options: -c -dlibelf -k_\n" + "Files: ../lib/errors.h\n" + + #: ../lib/errors.h:25 + msgid "no error" + msgstr "" + + #: ../lib/errors.h:26 + msgid "unknown error" + msgstr "" + + #: ../lib/errors.h:27 + msgid "Internal error: unknown reason" + msgstr "" + + #: ../lib/errors.h:28 + msgid "Internal error: not implemented" + msgstr "" + + #: ../lib/errors.h:29 + msgid "Request error: cntl(ELF_C_FDREAD) on write-only file" + msgstr "" + + #: ../lib/errors.h:30 + msgid "Request error: invalid ELF_C_* argument" + msgstr "" + + #: ../lib/errors.h:31 + msgid "Request error: file descriptor disabled" + msgstr "" + + #: ../lib/errors.h:32 + msgid "Request error: not an archive" + msgstr "" + + #: ../lib/errors.h:33 + msgid "Request error: offset out of range" + msgstr "" + + #: ../lib/errors.h:34 + msgid "Request error: unknown ELF version" + msgstr "" + + #: ../lib/errors.h:35 + msgid "Request error: ELF_C_* argument does not match" + msgstr "" + + #: ../lib/errors.h:36 + msgid "Request error: archive member begin() for writing" + msgstr "" + + #: ../lib/errors.h:37 + msgid "Request error: archive/member file descriptor mismatch" + msgstr "" + + #: ../lib/errors.h:38 + msgid "Request error: not an ELF file" + msgstr "" + + #: ../lib/errors.h:39 + msgid "Request error: class file/memory mismatch" + msgstr "" + + #: ../lib/errors.h:40 + msgid "Request error: invalid ELF_T_* argument" + msgstr "" + + #: ../lib/errors.h:41 + msgid "Request error: unknown data encoding" + msgstr "" + + #: ../lib/errors.h:42 + msgid "Request error: destination buffer too small" + msgstr "" + + #: ../lib/errors.h:43 + msgid "Request error: d_buf is NULL" + msgstr "" + + #: ../lib/errors.h:44 + msgid "Request error: unknown ELF class" + msgstr "" + + #: ../lib/errors.h:45 + msgid "Request error: section does not belong to file" + msgstr "" + + #: ../lib/errors.h:46 + msgid "Request error: no section at index" + msgstr "" + + #: ../lib/errors.h:47 + msgid "Request error: can't manipulate null section" + msgstr "" + + #: ../lib/errors.h:48 + msgid "Request error: data does not belong to section" + msgstr "" + + #: ../lib/errors.h:49 + msgid "Request error: no string table" + msgstr "" + + #: ../lib/errors.h:50 + msgid "Request error: string table offset out of range" + msgstr "" + + #: ../lib/errors.h:51 + msgid "Request error: update(ELF_C_WRITE) on read-only file" + msgstr "" + + #: ../lib/errors.h:52 + msgid "I/O error: seek" + msgstr "" + + #: ../lib/errors.h:53 + msgid "I/O error: file too big for memory" + msgstr "" + + #: ../lib/errors.h:54 + msgid "I/O error: raw read" + msgstr "" + + #: ../lib/errors.h:55 + msgid "I/O error: get file size" + msgstr "" + + #: ../lib/errors.h:56 + msgid "I/O error: output write" + msgstr "" + + #: ../lib/errors.h:57 + msgid "I/O error: can't truncate output file" + msgstr "" + + #: ../lib/errors.h:58 + msgid "Sequence error: must set ELF version first" + msgstr "" + + #: ../lib/errors.h:59 + msgid "Sequence error: must create ELF header first" + msgstr "" + + #: ../lib/errors.h:60 + msgid "Format error: reference outside file" + msgstr "" + + #: ../lib/errors.h:61 + msgid "Format error: archive header truncated" + msgstr "" + + #: ../lib/errors.h:62 + msgid "Format error: archive fmag" + msgstr "" + + #: ../lib/errors.h:63 + msgid "Format error: archive header" + msgstr "" + + #: ../lib/errors.h:64 + msgid "Format error: archive member truncated" + msgstr "" + + #: ../lib/errors.h:65 + msgid "Format error: archive symbol table size" + msgstr "" + + #: ../lib/errors.h:66 + msgid "Format error: archive string table" + msgstr "" + + #: ../lib/errors.h:67 + msgid "Format error: archive special name unknown" + msgstr "" + + #: ../lib/errors.h:68 + msgid "Format error: ELF header truncated" + msgstr "" + + #: ../lib/errors.h:69 + msgid "Format error: program header table truncated" + msgstr "" + + #: ../lib/errors.h:70 + msgid "Format error: section header table truncated" + msgstr "" + + #: ../lib/errors.h:71 + msgid "Format error: data region truncated" + msgstr "" + + #: ../lib/errors.h:72 + msgid "Format error: program header table alignment" + msgstr "" + + #: ../lib/errors.h:73 + msgid "Format error: section header table alignment" + msgstr "" + + #: ../lib/errors.h:74 + msgid "Format error: bad parameter in Verdef record" + msgstr "" + + #: ../lib/errors.h:75 + msgid "Format error: unknown Verdef version" + msgstr "" + + #: ../lib/errors.h:76 + msgid "Format error: bad parameter in Verneed record" + msgstr "" + + #: ../lib/errors.h:77 + msgid "Format error: unknown Verneed version" + msgstr "" + + #: ../lib/errors.h:78 + msgid "Format error: bad e_shnum value" + msgstr "" + + #: ../lib/errors.h:79 + msgid "Format error: unterminated string in string table" + msgstr "" + + #: ../lib/errors.h:80 + msgid "Layout error: section size too small for data" + msgstr "" + + #: ../lib/errors.h:81 + msgid "Layout error: overlapping sections" + msgstr "" + + #: ../lib/errors.h:82 + msgid "Memory error: elf descriptor" + msgstr "" + + #: ../lib/errors.h:83 + msgid "Memory error: archive symbol table" + msgstr "" + + #: ../lib/errors.h:84 + msgid "Memory error: archive member header" + msgstr "" + + #: ../lib/errors.h:85 + msgid "Memory error: ELF header" + msgstr "" + + #: ../lib/errors.h:86 + msgid "Memory error: program header table" + msgstr "" + + #: ../lib/errors.h:87 + msgid "Memory error: section header table" + msgstr "" + + #: ../lib/errors.h:88 + msgid "Memory error: section descriptor" + msgstr "" + + #: ../lib/errors.h:89 + msgid "Memory error: section data" + msgstr "" + + #: ../lib/errors.h:90 + msgid "Memory error: output file space" + msgstr "" + + #: ../lib/errors.h:91 + msgid "Memory error: temporary buffer" + msgstr "" + + #: ../lib/errors.h:92 + msgid "GElf error: value out of range" + msgstr "" + + #: ../lib/errors.h:93 + msgid "GElf error: index out of range" + msgstr "" + + #: ../lib/errors.h:94 + msgid "GElf error: type mismatch" + msgstr "" + + #: ../lib/errors.h:95 + msgid "GElf error: not enough memory for GElf_Sym" + msgstr "" + + #: ../lib/errors.h:96 + msgid "GElf error: not enough memory for GElf_Dyn" + msgstr "" + + #: ../lib/errors.h:97 + msgid "GElf error: not enough memory for GElf_Rela" + msgstr "" + + #: ../lib/errors.h:98 + msgid "GElf error: not enough memory for GElf_Rel" + msgstr "" Index: llvm/lib/CodeGen/ELF/po/stamp-po diff -c /dev/null llvm/lib/CodeGen/ELF/po/stamp-po:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/po/stamp-po Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1 ---- + timestamp From reid at x10sys.com Wed Jun 22 01:36:10 2005 From: reid at x10sys.com (Reid Spencer) Date: Wed, 22 Jun 2005 01:36:10 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/COPYING.LIB ChangeLog INSTALL MANIFEST Makefile.in README VERSION acconfig.h aclocal.m4 config.guess config.h.in config.sub configure configure.in install-sh mkinstalldirs stamp-h.in Message-ID: <200506220636.BAA04169@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF: COPYING.LIB added (r1.1) ChangeLog added (r1.1) INSTALL added (r1.1) MANIFEST added (r1.1) Makefile.in added (r1.1) README added (r1.1) VERSION added (r1.1) acconfig.h added (r1.1) aclocal.m4 added (r1.1) config.guess added (r1.1) config.h.in added (r1.1) config.sub added (r1.1) configure added (r1.1) configure.in added (r1.1) install-sh added (r1.1) mkinstalldirs added (r1.1) stamp-h.in added (r1.1) --- Log message: Adding libELF 0.8.5. This is the first baby step towards supporting direct generation of ELF files in LLVM. Its not clear at this point that all of the software added by this commit is actually needed. However, until requirements are solidified, I've included the whole thing. Note that this currently won't be built by the makefile system. Once an LLVM interface to this software is available, we'll start building libELF in order to provide the functionality. --- Diffs of the changes: (+9664 -0) COPYING.LIB | 481 +++++++ ChangeLog | 1023 ++++++++++++++++ INSTALL | 176 ++ MANIFEST | 88 + Makefile.in | 177 ++ README | 244 +++ VERSION | 1 acconfig.h | 80 + aclocal.m4 | 294 ++++ config.guess | 1407 ++++++++++++++++++++++ config.h.in | 136 ++ config.sub | 1505 ++++++++++++++++++++++++ configure | 3579 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ configure.in | 318 +++++ install-sh | 119 + mkinstalldirs | 35 stamp-h.in | 1 17 files changed, 9664 insertions(+) Index: llvm/lib/CodeGen/ELF/COPYING.LIB diff -c /dev/null llvm/lib/CodeGen/ELF/COPYING.LIB:1.1 *** /dev/null Wed Jun 22 01:36:07 2005 --- llvm/lib/CodeGen/ELF/COPYING.LIB Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,481 ---- + GNU LIBRARY GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + [This is the first released version of the library GPL. It is + numbered 2 because it goes with version 2 of the ordinary GPL.] + + Preamble + + The licenses for most software are designed to take away your + freedom to share and change it. By contrast, the GNU General Public + Licenses are intended to guarantee your freedom to share and change + free software--to make sure the software is free for all its users. + + This license, the Library General Public License, applies to some + specially designated Free Software Foundation software, and to any + other libraries whose authors decide to use it. You can use it for + your libraries, too. + + When we speak of free software, we are referring to freedom, not + price. Our General Public Licenses are designed to make sure that you + have the freedom to distribute copies of free software (and charge for + this service if you wish), that you receive source code or can get it + if you want it, that you can change the software or use pieces of it + in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid + anyone to deny you these rights or to ask you to surrender the rights. + These restrictions translate to certain responsibilities for you if + you distribute copies of the library, or if you modify it. + + For example, if you distribute copies of the library, whether gratis + or for a fee, you must give the recipients all the rights that we gave + you. You must make sure that they, too, receive or can get the source + code. If you link a program with the library, you must provide + complete object files to the recipients so that they can relink them + with the library, after making changes to the library and recompiling + it. And you must show them these terms so they know their rights. + + Our method of protecting your rights has two steps: (1) copyright + the library, and (2) offer you this license which gives you legal + permission to copy, distribute and/or modify the library. + + Also, for each distributor's protection, we want to make certain + that everyone understands that there is no warranty for this free + library. If the library is modified by someone else and passed on, we + want its recipients to know that what they have is not the original + version, so that any problems introduced by others will not reflect on + the original authors' reputations. + + Finally, any free program is threatened constantly by software + patents. We wish to avoid the danger that companies distributing free + software will individually obtain patent licenses, thus in effect + transforming the program into proprietary software. To prevent this, + we have made it clear that any patent must be licensed for everyone's + free use or not licensed at all. + + Most GNU software, including some libraries, is covered by the ordinary + GNU General Public License, which was designed for utility programs. This + license, the GNU Library General Public License, applies to certain + designated libraries. This license is quite different from the ordinary + one; be sure to read it in full, and don't assume that anything in it is + the same as in the ordinary license. + + The reason we have a separate public license for some libraries is that + they blur the distinction we usually make between modifying or adding to a + program and simply using it. Linking a program with a library, without + changing the library, is in some sense simply using the library, and is + analogous to running a utility program or application program. However, in + a textual and legal sense, the linked executable is a combined work, a + derivative of the original library, and the ordinary General Public License + treats it as such. + + Because of this blurred distinction, using the ordinary General + Public License for libraries did not effectively promote software + sharing, because most developers did not use the libraries. We + concluded that weaker conditions might promote sharing better. + + However, unrestricted linking of non-free programs would deprive the + users of those programs of all benefit from the free status of the + libraries themselves. This Library General Public License is intended to + permit developers of non-free programs to use free libraries, while + preserving your freedom as a user of such programs to change the free + libraries that are incorporated in them. (We have not seen how to achieve + this as regards changes in header files, but we have achieved it as regards + changes in the actual functions of the Library.) The hope is that this + will lead to faster development of free libraries. + + The precise terms and conditions for copying, distribution and + modification follow. Pay close attention to the difference between a + "work based on the library" and a "work that uses the library". The + former contains code derived from the library, while the latter only + works together with the library. + + Note that it is possible for a library to be covered by the ordinary + General Public License rather than by this special one. + + GNU LIBRARY GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library which + contains a notice placed by the copyright holder or other authorized + party saying it may be distributed under the terms of this Library + General Public License (also called "this License"). Each licensee is + addressed as "you". + + A "library" means a collection of software functions and/or data + prepared so as to be conveniently linked with application programs + (which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work + which has been distributed under these terms. A "work based on the + Library" means either the Library or any derivative work under + copyright law: that is to say, a work containing the Library or a + portion of it, either verbatim or with modifications and/or translated + straightforwardly into another language. (Hereinafter, translation is + included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for + making modifications to it. For a library, complete source code means + all the source code for all modules it contains, plus any associated + interface definition files, plus the scripts used to control compilation + and installation of the library. + + Activities other than copying, distribution and modification are not + covered by this License; they are outside its scope. The act of + running a program using the Library is not restricted, and output from + such a program is covered only if its contents constitute a work based + on the Library (independent of the use of the Library in a tool for + writing it). Whether that is true depends on what the Library does + and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's + complete source code as you receive it, in any medium, provided that + you conspicuously and appropriately publish on each copy an + appropriate copyright notice and disclaimer of warranty; keep intact + all the notices that refer to this License and to the absence of any + warranty; and distribute a copy of this License along with the + Library. + + You may charge a fee for the physical act of transferring a copy, + and you may at your option offer warranty protection in exchange for a + fee. + + 2. You may modify your copy or copies of the Library or any portion + of it, thus forming a work based on the Library, and copy and + distribute such modifications or work under the terms of Section 1 + above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + + These requirements apply to the modified work as a whole. If + identifiable sections of that work are not derived from the Library, + and can be reasonably considered independent and separate works in + themselves, then this License, and its terms, do not apply to those + sections when you distribute them as separate works. But when you + distribute the same sections as part of a whole which is a work based + on the Library, the distribution of the whole must be on the terms of + this License, whose permissions for other licensees extend to the + entire whole, and thus to each and every part regardless of who wrote + it. + + Thus, it is not the intent of this section to claim rights or contest + your rights to work written entirely by you; rather, the intent is to + exercise the right to control the distribution of derivative or + collective works based on the Library. + + In addition, mere aggregation of another work not based on the Library + with the Library (or with a work based on the Library) on a volume of + a storage or distribution medium does not bring the other work under + the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public + License instead of this License to a given copy of the Library. To do + this, you must alter all the notices that refer to this License, so + that they refer to the ordinary GNU General Public License, version 2, + instead of to this License. (If a newer version than version 2 of the + ordinary GNU General Public License has appeared, then you can specify + that version instead if you wish.) Do not make any other change in + these notices. + + Once this change is made in a given copy, it is irreversible for + that copy, so the ordinary GNU General Public License applies to all + subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of + the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or + derivative of it, under Section 2) in object code or executable form + under the terms of Sections 1 and 2 above provided that you accompany + it with the complete corresponding machine-readable source code, which + must be distributed under the terms of Sections 1 and 2 above on a + medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy + from a designated place, then offering equivalent access to copy the + source code from the same place satisfies the requirement to + distribute the source code, even though third parties are not + compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the + Library, but is designed to work with the Library by being compiled or + linked with it, is called a "work that uses the Library". Such a + work, in isolation, is not a derivative work of the Library, and + therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library + creates an executable that is a derivative of the Library (because it + contains portions of the Library), rather than a "work that uses the + library". The executable is therefore covered by this License. + Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file + that is part of the Library, the object code for the work may be a + derivative work of the Library even though the source code is not. + Whether this is true is especially significant if the work can be + linked without the Library, or if the work is itself a library. The + threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data + structure layouts and accessors, and small macros and small inline + functions (ten lines or less in length), then the use of the object + file is unrestricted, regardless of whether it is legally a derivative + work. (Executables containing this object code plus portions of the + Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may + distribute the object code for the work under the terms of Section 6. + Any executables containing that work also fall under Section 6, + whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also compile or + link a "work that uses the Library" with the Library to produce a + work containing portions of the Library, and distribute that work + under terms of your choice, provided that the terms permit + modification of the work for the customer's own use and reverse + engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the + Library is used in it and that the Library and its use are covered by + this License. You must supply a copy of this License. If the work + during execution displays copyright notices, you must include the + copyright notice for the Library among them, as well as a reference + directing the user to the copy of this License. Also, you must do one + of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + c) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + d) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the + Library" must include any data and utility programs needed for + reproducing the executable from it. However, as a special exception, + the source code distributed need not include anything that is normally + distributed (in either source or binary form) with the major + components (compiler, kernel, and so on) of the operating system on + which the executable runs, unless that component itself accompanies + the executable. + + It may happen that this requirement contradicts the license + restrictions of other proprietary libraries that do not normally + accompany the operating system. Such a contradiction means you cannot + use both them and the Library together in an executable that you + distribute. + + 7. You may place library facilities that are a work based on the + Library side-by-side in a single library together with other library + facilities not covered by this License, and distribute such a combined + library, provided that the separate distribution of the work based on + the Library and of the other library facilities is otherwise + permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute + the Library except as expressly provided under this License. Any + attempt otherwise to copy, modify, sublicense, link with, or + distribute the Library is void, and will automatically terminate your + rights under this License. However, parties who have received copies, + or rights, from you under this License will not have their licenses + terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not + signed it. However, nothing else grants you permission to modify or + distribute the Library or its derivative works. These actions are + prohibited by law if you do not accept this License. Therefore, by + modifying or distributing the Library (or any work based on the + Library), you indicate your acceptance of this License to do so, and + all its terms and conditions for copying, distributing or modifying + the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the + Library), the recipient automatically receives a license from the + original licensor to copy, distribute, link with or modify the Library + subject to these terms and conditions. You may not impose any further + restrictions on the recipients' exercise of the rights granted herein. + You are not responsible for enforcing compliance by third parties to + this License. + + 11. If, as a consequence of a court judgment or allegation of patent + infringement or for any other reason (not limited to patent issues), + conditions are imposed on you (whether by court order, agreement or + otherwise) that contradict the conditions of this License, they do not + excuse you from the conditions of this License. If you cannot + distribute so as to satisfy simultaneously your obligations under this + License and any other pertinent obligations, then as a consequence you + may not distribute the Library at all. For example, if a patent + license would not permit royalty-free redistribution of the Library by + all those who receive copies directly or indirectly through you, then + the only way you could satisfy both it and this License would be to + refrain entirely from distribution of the Library. + + If any portion of this section is held invalid or unenforceable under any + particular circumstance, the balance of the section is intended to apply, + and the section as a whole is intended to apply in other circumstances. + + It is not the purpose of this section to induce you to infringe any + patents or other property right claims or to contest validity of any + such claims; this section has the sole purpose of protecting the + integrity of the free software distribution system which is + implemented by public license practices. Many people have made + generous contributions to the wide range of software distributed + through that system in reliance on consistent application of that + system; it is up to the author/donor to decide if he or she is willing + to distribute software through any other system and a licensee cannot + impose that choice. + + This section is intended to make thoroughly clear what is believed to + be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in + certain countries either by patents or by copyrighted interfaces, the + original copyright holder who places the Library under this License may add + an explicit geographical distribution limitation excluding those countries, + so that distribution is permitted only in or among countries not thus + excluded. In such case, this License incorporates the limitation as if + written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new + versions of the Library General Public License from time to time. + Such new versions will be similar in spirit to the present version, + but may differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the Library + specifies a version number of this License which applies to it and + "any later version", you have the option of following the terms and + conditions either of that version or of any later version published by + the Free Software Foundation. If the Library does not specify a + license version number, you may choose any version ever published by + the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free + programs whose distribution conditions are incompatible with these, + write to the author to ask for permission. For software which is + copyrighted by the Free Software Foundation, write to the Free + Software Foundation; we sometimes make exceptions for this. Our + decision will be guided by the two goals of preserving the free status + of all derivatives of our free software and of promoting the sharing + and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO + WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. + EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR + OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY + KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE + LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME + THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN + WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY + AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU + FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR + CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE + LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING + RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A + FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF + SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest + possible use to the public, we recommend making it free software that + everyone can redistribute and change. You can do so by permitting + redistribution under these terms (or, alternatively, under the terms of the + ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is + safest to attach them to the start of each source file to most effectively + convey the exclusion of warranty; and each file should have at least the + "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Also add information on how to contact you by electronic and paper mail. + + You should also get your employer (if you work as a programmer) or your + school, if any, to sign a "copyright disclaimer" for the library, if + necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + + That's all there is to it! Index: llvm/lib/CodeGen/ELF/ChangeLog diff -c /dev/null llvm/lib/CodeGen/ELF/ChangeLog:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/ChangeLog Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,1023 ---- + Fri Dec 5 16:25:16 CET 2003, Michael Riepe + + * aclocal.m4: + add explanation for --enable-maintainer-mode + * lib/Makefile.in: + * po/Makefile.in: + add instroot make variable + * README: + add hint how to use it + + Thu Nov 6 17:35:00 CET 2003, Michael Riepe + + * Makefile.in: + * lib/Makefile.in: + * po/Makefile.in: + add check targets + add MANIFEST to distribution + * aclocal.m4: + add mr_PACKAGE macro + * configure.in: + use mr_PACKAGE macro + + Sat Oct 25 15:22:59 CEST 2003, Michael Riepe + + * lib/elf_repl.h: + add EM_SPARC64 + + Thu Oct 9 23:08:56 CEST 2003, Michael Riepe + + * lib/x.movscn.c: + * lib/x.remscn.c: + verify that file is really an ELF file + + Wed Oct 8 17:10:09 CEST 2003, Michael Riepe + + * config.guess: + * config.sub: + latest versions from FSF + + Sat May 24 18:55:14 CEST 2003, Michael Riepe + + * config.guess: + latest version from FSF + * lib/Makefile.in: + * lib/libelf.h: + * lib/x.movscn.c: + * lib/x.remscn.c: + add elfx_movscn() and elfx_remscn() + * lib/newscn.c: + update e_shnum properly + * lib/private.h: + declare _elf_update_shnum() + + Fri May 23 18:25:48 CEST 2003, Michael Riepe + + * aclocal.m4: + provide name suffixes only + * lib/Makefile.in: + use name suffixes + + Fri May 23 01:24:26 CEST 2003, Michael Riepe + + * README: + update for 0.8.5 + add section about LFS + * config.guess: + latest version from FSF + * configure.in: + * lib/Makefile.in: + use local pic object directory + * lib/checksum.c: + detect d_buf == NULL + + Sun May 18 16:49:10 CEST 2003, Michael Riepe + + * VERSION: + bump up to 0.8.5 + * lib/strptr.c: + make elf_strptr() work safely with fragmented string tables + * lib/errors.h: + new error code and message for elf_strptr() + * po/de.po: + * po/libelf.po: + regenerated + + Mon May 12 15:29:12 CEST 2003, Michael Riepe + + * lib/update.c: + improved fix for elf_update `null buffer' bug + + Mon May 12 00:34:44 CEST 2003, Michael Riepe + + * config.guess: + * config.sub: + latest versions from FSF + + Sun May 11 01:44:06 CEST 2003, Michael Riepe + + * lib/verdef.h: + * lib/verneed.h: + fix elf_update `null buffer' error. + Thanks to Bart Trojanowski who reported the bug. + + Wed May 7 20:26:17 CEST 2003, Michael Riepe + + * configure.in: + fix maintainer mode default + * lib/verdef.h: + * lib/verneed.h: + only check d_buf if there is at least one element + + Mon Mar 31 17:08:04 CEST 2003, Michael Riepe + + * VERSION: + bump up to 0.8.4 + + Sun Mar 23 16:06:43 CET 2003, Michael Riepe + + * configure.in: + fix --enable-compat + + Thu Feb 27 14:35:12 CET 2003, Michael Riepe + + * Makefile.in: + add `test-dist' target + * lib/errors.h: + new error code + * po/de.po: + * po/libelf.pot: + regenerated + + Wed Feb 26 17:48:58 CET 2003, Michael Riepe + + * config.guess: + * config.sub: + latest versions from FSF + + Wed Jan 15 22:50:53 CET 2003, Michael Riepe + + * lib/begin.c: + fix overflow check + + Sun Jan 12 04:27:31 CET 2003, Michael Riepe + + * configure.in: + prefer int for __libelf_i32_t (if int has 32 bits) + + Thu Jan 2 17:40:22 CET 2003, Michael Riepe + + * README: + update for 0.8.3 + * config.guess: + * config.sub: + update from ftp.gnu.org + * lib/cook.c: + require space for one SHDR only + * lib/elf_repl.h: + fix DT_ENCODING value + + Tue Dec 31 16:27:19 CET 2002, Michael Riepe + + * lib/cook.c: + honor ELF extensions for >= 0xff00 sections + * lib/elf_repl.h: + add definitions from lates ELF spec + * lib/errors.h: + * po/libelf.pot: + * po/de.po: + new error message + * lib/private.h: + define missing pieces + * lib/update.c: + handle >= 0xff00 sections + + Mon Dec 23 00:23:20 CET 2002, Michael Riepe + + * lib/Makefile.in: + fix dependencies. + * lib/cook.c: + add quirks mode for broken 64-bit architectures. + * lib/update.c: + do not override sh_entsize unless it's set to 0. + * lib/verdef.h: + * lib/verneed.h: + work around possible SEGV in translation routines. + + Sat Dec 14 23:33:10 CET 2002, Michael Riepe + + * ChangeLog: + add missing entries for 0.8.2 release. + * VERSION: + bump up to 0.8.3. + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + * lib/verdef.h: + * lib/verneed.h: + fix ISO C violations (required for MacOS X). + * po/gmo2msg.c: + create SUSv3 compliant .msg files. + + Thu Jun 11 19:00:19 CEST 2002, Michael Riepe + + * README: + update for 0.8.2. + * VERSION: + bump up to 0.8.2. + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + fix typos in for loop. + * lib/nlist.c: + add O_BINARY to file mode + (defaults to 0 on systems that lack it). + + Tue Dec 25 14:42:51 CET 2001, Michael Riepe + + * VERSION: + set version to 0.8.0. + * README: + update version. + + Tue Oct 30 17:05:03 CET 2001, Michael Riepe + + * Makefile.in: + use uid/gid=0 when creating the distribution tar file. + + Mon Oct 15 23:47:10 CEST 2001, Michael Riepe + + * configure.in: + check for and . + create ./pic when configuring. + * lib/Makefile.in: + move .o to ../pic/$@, not ../pic. + * lib/begin.c: + define struct ar_hdr and friends if is missing. + use lseek(..., SEEK_END). + * lib/input.c: + use lseek(..., SEEK_SET). + * lib/nlist.c: + include conditionally. + define O_RDONLY if it is missing. + * lib/private.h: + define SEEK_{SET,CUR,END} if they're missing. + * lib/update.c: + explicitly pass file descriptor to _elf_output(). + use lseek(..., SEEK_SET). + + Tue Oct 9 22:46:01 CEST 2001, Michael Riepe + + * aclocal.m4: + remove superfluous case. + + Mon Oct 8 17:56:04 CEST 2001, Michael Riepe + + * lib/opt.delscn.c: + handle versioning sections properly. + + Mon Oct 8 17:02:43 CEST 2001, Michael Riepe + + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + override encoding when calculating the destination buffer + size for translation to a file. + + Sun Oct 7 21:31:01 CEST 2001, Michael Riepe + + * configure.in: + drop OBJS64; always compile 64-bit sources. + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + add translators for versioning structures. + * lib/Makefile.in: + drop OBJS64; add versioning support files. + * lib/errors.h: + add error codes for versioning support. + * lib/gelfehdr.c: + * lib/gelfphdr.c: + * lib/gelfshdr.c: + * lib/gelftrans.c: + * lib/swap64.c: + guard code with `#if __LIBELF64'. + * lib/private.h: + add translator declarations. + * po/de.po: + * po/libelf.pot: + add error messages for versioning support. + + Sun Oct 7 16:54:15 CEST 2001, Michael Riepe + + * acconfig.h: + * configure.in: + improve auto-configuration. + * lib/Makefile.in: + * po/Makefile.in + let users override distdir. + * lib/cook.c: + improved bugfix based on new auto-configuration. + * lib/getdata.c: + prepare src first to prevent SEGV. + * lib/private.h: + * lib/update.c: + cosmetic changes. + + Sun Oct 7 05:50:19 CEST 2001, Michael Riepe + + * configure.in: + * lib/cook.c: + fix compilation problem on Linux (SHT_SUNW_ver* undefined). + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + make translator functions calculate the destination size. + add _elf32_xltsize and _elf64_xltsize entry points. + * lib/private.h: + declare _elf32_xltsize and _elf64_xltsize. + * lib/getdata.c: + * lib/update.c: + use _elf32_xltsize and _elf64_xltsize. + + Fri Oct 5 20:35:31 CEST 2001, Michael Riepe + + * lib/elf_repl.h: + add DT_VERSYM. + * lib/ext_types.h: + correct type names. + * lib/libelf.h: + add ELF_T_VDEF and ELF_T_VNEED. + * lib/32.fsize.c: + add table entries for versioning structures. + * lib/cook.c: + replace _elf_scn_types[] with _elf_scn_type(). + * lib/private.h: + likewise; also remove valid_scntype() macro. + * lib/update.c: + call _elf_scn_type(), but do not set sh_entsize + for ELF_T_VDEF / ELF_T_VNEED. + * acconfig.h: + * lib/sys_elf.h.in: + added __LIBELF_SYMBOL_VERSIONS. + * configure.in: + check for symbol versioning definitions. + * lib/Makefile.in: + added gelf.h dependency. + + Wed Oct 3 22:46:33 CEST 2001, Michael Riepe + + * lib/swap64.c: + new file; separate 64-bit functions. + * lib/64.xlatetof.c: + remove 64-bit conversion functions. + * lib/byteswap.h: + replace casts to long / unsigned long. + add prototypes for 64-bit conversion functions. + * configure.in: + * lib/Makefile.in: + add lib/swap64.c. + * lib/ext_types.h: + add type definitions for versioning. + * lib/elf_repl.h: + * lib/gelf.h: + cosmetic changes. + + Wed Oct 3 00:00:27 CEST 2001, Michael Riepe + + * lib/elf_repl.h: + added lots of new definitions. + * lib/gelf.h: + * lib/libelf.h: + * lib/sys_elf.h.in: + cosmetic changes. + + Fri Sep 28 22:42:36 CEST 2001, Michael Riepe + + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + remove `const' when compiling with -fPIC. + + Fri Sep 28 20:14:42 CEST 2001, Michael Riepe + + * README: + add pointers to documentation. + * lib/64.xlatetof.c: + fixed conversion thinko. + (Jakub Jelinek found this - thanks!) + * lib/gelf.h: + * lib/32.fsize.c: + add gelf_msize. + * lib/libelf.h: + add comment that elf{32,64}_checksum is missing. + + Tue Sep 11 02:43:47 CEST 2001, Michael Riepe + + * README: + corrected typo. + * lib/cook.c: + * lib/private.h: + * lib/update.c: + replaces _ELFxx_ALIGN_xHDR with _fsize() call. + + Sun Sep 2 20:58:09 CEST 2001, Michael Riepe + + * Makefile.in: + * configure.in: + * lib/Makefile.in: + * po/Makefile.in: + add maintainer mode. + + Sat Sep 1 15:11:42 CEST 2001, Michael Riepe + + * lib/sys_elf.h.in: add more fixes for broken files. + + Sat Sep 1 05:01:16 CEST 2001, Michael Riepe + + * ChangeLog: major update. Yes, I'm back. + + * COPYING.LIB: updated version from FSF. + + * README: updated for 0.7.1. + + Thu Apr 20 17:09:41 CEST 2000, Michael Riepe + + * lib/gelftrans.c: + * lib/elf_repl.h: + add explicit casts to ELF64_R_SYM and ELF64_R_INFO. + + Thu Apr 13 20:15:45 CEST 2000, Michael Riepe + + * lib/update.c: better checks for overlapping sections. + + * lib/errors.h: + * po/de.po: + * po/libelf.pot: + new error message. + + Thu Apr 6 19:15:46 CEST 2000, Michael Riepe + + * lib/strptr.c: rename `sd' variable. + + Fri Mar 31 20:11:14 CEST 2000, Michael Riepe + + * Makefile.in: also pass CPPFLAGS and LDFLAGS to config.status. + + Fri Mar 31 20:02:55 CEST 2000, Michael Riepe + + * aclocal.m4: add -DPIC define when building position-independent code. + + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: + * lib/errmsg.c: + make array members const when PIC is undefined. + + Fri Mar 31 14:42:32 CEST 2000, Michael Riepe + + * lib/32.newehdr.c: make _elf_newehdr() function private again. + + * lib/32.newphdr.c: make _elf_newphdr() function private again. + + * lib/strptr.c: add support for 64-bit ELF format. + + Wed Mar 29 18:49:43 CEST 2000, Michael Riepe + + * lib/gelfshdr.c: remove ELF class check. + + Mon Mar 27 01:24:50 CEST 2000, Michael Riepe + + * lib/gelf.h: #include when compiling libelf. + + Sun Mar 26 15:02:54 CEST 2000, Michael Riepe + + * lib/private.h: #include header file. + + * lib/gelfehdr.c: move gelf_newehdr() function to lib/32.newehdr.c. + + * lib/gelfphdr.c: move gelf_newphdr() function to lib/32.newphdr.c. + + * lib/32.newehdr.c: add gelf_newehdr() function. + + * lib/32.newphdr.c: add gelf_newphdr() function. + + * lib/gelfshdr.c: + * lib/gelftrans.c: + remove explicit include. + + Sun Mar 26 06:22:20 CEST 2000, Michael Riepe + + * acconfig.h: + * configure.in: + * lib/private.h: + * lib/sys_elf.h.in: + rename NEED_LINK_H to __LIBELF_NEED_LINK_H. + + * lib/32.newehdr.c: make _elf_newehdr() function public. + + * lib/32.newphdr.c: make _elf_newphdr() function public. + + * lib/gelf.h: + include if needed. + choke if 64-bit is not supported. + add generic versions of ELF32_* and ELF64_* macros. + + * lib/gelftrans.c: + define ELF32_R_* and ELF64_R_* macros (missing on some systems). + + Sun Mar 26 05:27:15 CEST 2000, Michael Riepe + + * configure.in: + add check for existing header. + build new source files when 64-bit is enabled. + + * lib/Makefile.in: + add new source files. + make install-compat if --enable-compat was given. + + * po/de.po: + * po/libelf.pot: + new error messages. + + Sun Mar 26 05:00:20 CEST 2000, Michael Riepe + + * Makefile.in: + * lib/Makefile.in: + * po/Makefile.in: + remove Makefile last in `make distclean'. + + * aclocal.m4: explicitly state the default in --enable-* help texts. + + * configure.in: + set ALL_LINGUAS automatically. + add `--enable-compat' option. + + * lib/private.h: add sd_scn member to struct Scn_Data. + + * lib/cook.c: + * lib/end.c: + * lib/getdata.c: + * lib/newdata.c: + * lib/opt.delscn.c: + * lib/rawdata.c: + * lib/update.c: + handle new sd_scn member. + + * lib/gelf.h: new public header file. + + * lib/gelfehdr.c: new file, implements the gelf_getehdr(), + gelf_update_ehdr() and gelf_newehdr() functions. + + * lib/gelfphdr.c: new file, implements the gelf_getphdr(), + gelf_update_phdr() and gelf_newphdr() functions. + + * lib/gelfshdr.c: new file, implements the gelf_getshdr() + and gelf_update_shdr() functions. + + * lib/gelftrans.c: new file, implements the gelf_getsym(), + gelf_update_sym(), gelf_getdyn(), gelf_update_dyn(), + gelf_getrela(), gelf_update_rela(), gelf_getrel() and + gelf_update_rel() functions. + + * lib/begin.c: add gelf_getclass() function. + + * lib/32.fsize.c: add gelf_fsize() function. + + * lib/32.getphdr.c: make _elf_getphdr() function public. + + * lib/64.xlatetof.c: + add gelf_xlatetom() and gelf_xlatetof() functions. + remove `const' from array members. + + * lib/errors.h: add GElf error messages. + + * po/de.po: + * po/libelf.pot: + new error message. + + Thu Nov 4 21:17:34 CET 1999, Michael Riepe + + * lib/32.xlatetof.c: + * lib/errmsg.c: + * po/gmo2msg.c: + remove `const' from array members. + + Thu Nov 4 20:16:36 CET 1999, Michael Riepe + + * lib/Makefile.in: add assert.c; remove stamp-h in `make distclean'. + + * lib/assert.c: new file, implements the __elf_assert() function. + + * lib/private.h: use __elf_assert() in elf_assert() macro. + + Wed Mar 17 16:21:02 CET 1999, Michael Riepe + + * configure.in: add "de" to ALL_LINGUAS. + + * lib/elf_repl.h: lots of new #defines. + + * lib/hash.c: + * lib/libelf.h: + elf_hash() takes an `const unsigned char *'. + + * po/gmo2msg.c: copy comments from .gmo file. + + Fri Mar 5 16:28:08 CET 1999, Michael Riepe + + * VERSION: set version to 0.7.1. + + * po/de.po: new file. + + Fri Nov 27 22:24:00 MET 1998, Michael Riepe + + * lib/memset.c: rename and rewrite. + * lib/private.h: rename __memset. + + Tue Aug 25 17:17:18 MEST 1998, Michael Riepe + + * aclocal.m4: remove superfluous #include. + + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: fix for picky instances of cpp(1). + + Sun Aug 23 18:26:53 MEST 1998, Michael Riepe + + * aclocal.m4: + * lib/Makefile.in: add DEPSHLIBS, set to -lc for Linux. + + * README: add DEPSHLIBS description. + + Sat Aug 22 15:50:41 MEST 1998, Michael Riepe + + * lib/begin.c: add workaround for broken ar(1) & friends. + + * lib/32.getshdr.c: fix typo. + + Thu Aug 6 18:11:52 MEST 1998, Michael Riepe + + * lib/getdata.c: fixed SEGV bug. + + * lib/cook.c: + * lib/getdata.c: + * lib/newdata.c: + * lib/rawdata.c: + * lib/private.h: removed sd_scn and (Elf_Data*) casts. + + Fri Jun 12 21:24:50 MEST 1998, Michael Riepe + + * lib/*.c: move rcsid[] after . + + * lib/32.xlatetof.c: + * lib/64.xlatetof.c: replace broken Exn() macro with Cat2(). + + * lib/64.xlatetof.c: change `char*' to `unsigned char*'. + + * lib/private.h: add `extern char *realloc();'. + + * aclocal.m4: + * configure.in: remove leading spaces in cpp directives. + + Sun Jun 7 16:02:31 MEST 1998, Michael Riepe + + * README: update for 0.7.0 release. + + Sun Jun 4 15:26:49 MEST 1998, Michael Riepe + + * acconfig.h: add __libelf64* and __libelf_*_t. + + * configure.in: clean up, add checks for 64-bit support. + + * lib/64.xlatetof.c: new file, based on lib/32.xlatetof.c. + + * lib/Makefile.in: add target for 64.xlatetof.o. + + * lib/cook.c: check for 32-bit overflow. + + * lib/elf_repl.h: + * lib/ext_types.h: add 64-bit data types. + + * lib/private.h: add 64-bit definitions. + + * lib/sys_elf.h.in: add __LIBELF64* and __libelf_*_t. + + * lib/update.c: add full 64-bit support. + + Mon Jun 1 16:29:07 MEST 1998, Michael Riepe + + * VERSION: change version to 0.7.0. + + * configure.in: + add lib/sys_elf.h to AC_CONFIG_HEADER. + new option --disable-elf64. + + * Makefile.in: add target for lib/sys_elf.h. + + * acconfig.h: add __LIBELF_HEADER_ELF_H. + + * lib/Makefile.in: add sys_elf.h(.in). + + * lib/32.fsize.c: + * lib/32.getehdr.c: + * lib/32.getphdr.c: + * lib/32.getshdr.c: + * lib/32.newehdr.c: + * lib/32.newphdr.c: + * lib/cook.c: + * lib/getdata.c: + * lib/libelf.h: + * lib/newscn.c: + * lib/nlist.c: + * lib/opt.delscn.c: + * lib/private.h: + * lib/update.c: + merged with 64bit code. + + * lib/begin.c: + * lib/input.c: + bug fixes. + + Fri Aug 1 19:33:33 MEST 1997, Michael Riepe + + * VERSION: change version to 0.6.5. + + * lib/libelf.h: add declaration for elf_memory. + + * lib/private.h: add e_memory flag. + + * lib/begin.c: add elf_memory, change archive freezing logic. + + * lib/end.c: do not free e_data if e_memory is set. + + Tue Oct 22 21:31:56 MEST 1996, Michael Riepe + + * (all files): add RCS Id, import to CVS. + + * Makefile.in: pass $(CC) to config.status. + + * README: change for upcoming 0.6.5 release. + + * aclocal.m4 (mr_ENABLE_NLS): add --enable-gnu-names option + + * configure.in: change search order for . + + * lib/begin.c (_elf_arhdr): add check for truncated archive member. + + * lib/cook.c (_elf32_cook): add checks for misaligned tables. + + * lib/errors.h: + fix wrong error message (ERROR_WRONLY). + add error messages for misaligned tables. + + * lib/private.h: add constants for table alignments. + + * po/Makefile.in: do not run mkinstalldirs directly, use $(SHELL). + + * po/libelf.pot: rebuild. + + Tue Jul 30 17:22:41 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.6.4. + + * Makefile.in: + add DISTSUBDIRS. + add po/Makefile target. + + * po/Makefile.in: + * po/gmo2msg.c: + * po/libelf.pot: + * po/stamp-po: + new files. + + * aclocal.m4 (mr_ENABLE_NLS): + add MSGFILES. + set GMOFILES, MSGFILES and POFILES even if NLS is disabled. + + * configure.in: + add ALL_LINGUAS. + + * lib/nlist.c: + call elf_errno() to clear pending error. + + Tue Jul 28 23:53:44 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.6.3. + + * configure.in: fix creation of sys_elf.h. + + * lib/Makefile.in: + move elf_repl.h to PRIVHDRS. + do not depend on HDRS and AUXHDRS. + + Sat Jul 27 18:27:09 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.6.2. + + * Makefile.in: + remove support from SUBDIRS. + remove subdirs/Makefile target. + + * acconfig.h: + add ENABLE_DEBUG. + remove HAVE_NLS. + + * aclocal.m4: + add mr_ENABLE_DEBUG. + + * configure.in: + use mr_ENABLE_DEBUG. + + * lib/Makefile.in: + add LD variable. + add elf_repl.h to DISTFILES. + + * lib/libelf.h: + add check for __LIBELF_INTERNAL__. + + * lib/private.h: + #define __LIBELF_INTERNAL__. + use ENABLE_DEBUG. + + * support/elf.h: + move to lib/elf_repl.h. + + * support/Makefile.in: + remove. + + Sat Jul 27 06:25:23 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.6.1. + + * aclocal.m4: add shared library support for sparc-sun-solaris2. + + * lib/libelf.h.in: remove. + + * lib/libelf.h: new file. + + * configure.in: + remove broken check for existing installation. + remove @install_headers@ and @elf_h at . + do not build libelf.h from libelf.h.in. + create lib/sys_elf.h. + + * lib/Makefile.in: + remove libelf.h and $(AUXHDRS) targets. + remove libelf.h.in from DISTFILES. + add libelf.h to DISTFILES. + add dummy_shlib target for broken make. + + Sat Jul 27 01:01:45 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.6.0. + + * lib: new directory. + + * config.sub: + * config.guess: + new files. + + * shared: + * shared/Makefile.in: + remove. + + * aclocal.m4: + * configure.in: + add shared library check. + + * Makefile.in: + * lib/Makefile.in: + change for new directory structure. + integrate shared library support. + + * Makefile.in: + remove libelf.lsm from DISTFILES. + + * libelf.lsm: remove. + + Thu Jul 25 19:35:05 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.5.9. + + * aclocal.m4: rewrite NLS check. + + Tue Jul 23 18:59:05 MET DST 1996, Michael Riepe + + * Makefile.in: add install-compat and uninstall-compat targets. + + * configure.in: + * aclocal.m4: + fix check for NLS support. + + * acconfig.h: add HAVE_CATGETS and HAVE_GETTEXT. + + * errmsg.c (elf_errmsg): use HAVE_GETTEXT. + + Sun Jul 21 22:52:02 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.5.8. + + * private.h: + * 32.getshdr.c: + * cook.c: + * end.c: + * newscn.c: + * opt.delscn.c: + * update.c: + change allocation of section headers. + + * errors.h: fix speeling error. + + Sat Jul 13 22:51:16 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.5.7. + + * private.h: add e_dsize member to struct Elf. + + * begin.c (elf_begin): set e_dsize. + + * update.c (_elf32_update_pointers): + never let e_data become shorter than e_dsize bytes. + use correct base pointer. + + Sat Jun 15 16:28:50 MET DST 1996, Michael Riepe + + * 32.xlatetof.c: change `char' to `unsigned char'. + + Tue May 28 19:00:30 MET DST 1996, Michael Riepe + + * Makefile.in: + HP-UX make wants non-empty target, change it. + add targets for TAGS and libelf.po. + + * errors.h: mark strings for GNU gettext. + + * mkmsgs: recognize new errors.h format. + + * errmsg.c (elf_errmsg): add gettext support. + + Mon May 27 20:30:30 MET DST 1996, Michael Riepe + + * VERSION: change version to 0.5.6. + + * aclocal.m4: + * configure.in: use new AC_CACHE_CHECK macro. + + * Makefile.in: + * shared/Makefile.in: use @...dir at . + + * Makefile.in: pass $(SRCS) and $(OBJS) to shared/Makefile. + + Sat May 25 01:00:15 MET DST 1996, Michael Riepe + + * update.c (elf_update): assert e_data is malloc'ed. + + * begin.c (elf_begin): mmap e_data if possible. + + * end.c (elf_end): munmap e_data if necessary. + + * input.c (_elf_mmap): new function. + + * private.h: add _elf_mmap and e_unmap_data. + + * errmsg.c: make pointer array constant. + + Thu May 23 19:24:47 MET DST 1996, Michael Riepe + + * update.c (elf_update): mmap(MAP_SHARED) wants non-empty file. + + Tue May 21 15:33:07 MET DST 1996, Michael Riepe + + * begin.c (elf_begin): re-read memory image of archive members. + + * cook.c (_elf32_item): + * getdata.c (_elf32_cook_scn): always use memory image. + + * update.c (_elf_update): use mmap if possible. + + * configure.in: check for mmap. + + Mon May 20 18:15:54 MET DST 1996, Michael Riepe + + * nlist.c (_elf_nlist): fix broken st_name range check. + + * update.c (_elf32_write): check status of elf_getdata. + + * cook.c (_elf32_item): + * getdata.c (_elf32_cook_scn): + use memory image when file is not an archive member. + + * rawdata.c (elf_rawdata): copy raw image rather than referencing it. + + Wed May 15 20:04:39 MET DST 1996, Michael Riepe + + * rawdata.c (elf_rawdata): use raw image if it is present. + + * cntl.c (elf_cntl): fix archive handling, ignore ELF_C_FDREAD for non-ELF files. + + Fri May 10 17:16:44 MET DST 1996, Michael Riepe + + * begin.c (_elf_arhdr): fix handling of long archive member names. + + * configure.in: move version information to external file. + + * Makefile.in: add VERSION to DISTFILES. + + * VERSION: new file. + + Sat May 4 20:56:43 MET DST 1996, Michael Riepe + + * configure.in: change version to 0.5.5. + + * Makefile.in: add libelf.lsm and ChangeLog to DISTFILES. + + * rawdata.c: reorder cases to avoid unnecessary malloc/free. + + * all files: update copyright phrase. + + * ChangeLog: + * libelf.lsm: new files. + + Sun Oct 29 19:34:00 MET 1995, Michael Riepe + + * configure.in: change version to 0.5.3. + + * Makefile.in: + * shared/Makefile.in: add opt.delscn.c. + + * libelf.h.in: add declaration for elf_delscn. + + * opt.delscn.c: new file. + Index: llvm/lib/CodeGen/ELF/INSTALL diff -c /dev/null llvm/lib/CodeGen/ELF/INSTALL:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/INSTALL Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,176 ---- + Basic Installation + ================== + + These are generic installation instructions. + + The `configure' shell script attempts to guess correct values for + various system-dependent variables used during compilation. It uses + those values to create a `Makefile' in each directory of the package. + It may also create one or more `.h' files containing system-dependent + definitions. Finally, it creates a shell script `config.status' that + you can run in the future to recreate the current configuration, a file + `config.cache' that saves the results of its tests to speed up + reconfiguring, and a file `config.log' containing compiler output + (useful mainly for debugging `configure'). + + If you need to do unusual things to compile the package, please try + to figure out how `configure' could check whether to do them, and mail + diffs or instructions to the address given in the `README' so they can + be considered for the next release. If at some point `config.cache' + contains results you don't want to keep, you may remove or edit it. + + The file `configure.in' is used to create `configure' by a program + called `autoconf'. You only need `configure.in' if you want to change + it or regenerate `configure' using a newer version of `autoconf'. + + The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. If you're + using `csh' on an old version of System V, you might need to type + `sh ./configure' instead to prevent `csh' from trying to execute + `configure' itself. + + Running `configure' takes awhile. While running, it prints some + messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + + Compilers and Options + ===================== + + Some systems require unusual options for compilation or linking that + the `configure' script does not know about. You can give `configure' + initial values for variables by setting them in the environment. Using + a Bourne-compatible shell, you can do that on the command line like + this: + CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure + + Or on systems that have the `env' program, you can do it like this: + env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure + + Compiling For Multiple Architectures + ==================================== + + You can compile the package for more than one kind of computer at the + same time, by placing the object files for each architecture in their + own directory. To do this, you must use a version of `make' that + supports the `VPATH' variable, such as GNU `make'. `cd' to the + directory where you want the object files and executables to go and run + the `configure' script. `configure' automatically checks for the + source code in the directory that `configure' is in and in `..'. + + If you have to use a `make' that does not supports the `VPATH' + variable, you have to compile the package for one architecture at a time + in the source code directory. After you have installed the package for + one architecture, use `make distclean' before reconfiguring for another + architecture. + + Installation Names + ================== + + By default, `make install' will install the package's files in + `/usr/local/bin', `/usr/local/man', etc. You can specify an + installation prefix other than `/usr/local' by giving `configure' the + option `--prefix=PATH'. + + You can specify separate installation prefixes for + architecture-specific files and architecture-independent files. If you + give `configure' the option `--exec-prefix=PATH', the package will use + PATH as the prefix for installing programs and libraries. + Documentation and other data files will still use the regular prefix. + + If the package supports it, you can cause programs to be installed + with an extra prefix or suffix on their names by giving `configure' the + option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + + Optional Features + ================= + + Some packages pay attention to `--enable-FEATURE' options to + `configure', where FEATURE indicates an optional part of the package. + They may also pay attention to `--with-PACKAGE' options, where PACKAGE + is something like `gnu-as' or `x' (for the X Window System). The + `README' should mention any `--enable-' and `--with-' options that the + package recognizes. + + For packages that use the X Window System, `configure' can usually + find the X include and library files automatically, but if it doesn't, + you can use the `configure' options `--x-includes=DIR' and + `--x-libraries=DIR' to specify their locations. + + Specifying the System Type + ========================== + + There may be some features `configure' can not figure out + automatically, but needs to determine by the type of host the package + will run on. Usually `configure' can figure that out, but if it prints + a message saying it can not guess the host type, give it the + `--host=TYPE' option. TYPE can either be a short name for the system + type, such as `sun4', or a canonical name with three fields: + CPU-COMPANY-SYSTEM + + See the file `config.sub' for the possible values of each field. If + `config.sub' isn't included in this package, then this package doesn't + need to know the host type. + + If you are building compiler tools for cross-compiling, you can also + use the `--target=TYPE' option to select the type of system they will + produce code for and the `--build=TYPE' option to select the type of + system on which you are compiling the package. + + Sharing Defaults + ================ + + If you want to set default values for `configure' scripts to share, + you can create a site shell script called `config.site' that gives + default values for variables like `CC', `cache_file', and `prefix'. + `configure' looks for `PREFIX/share/config.site' if it exists, then + `PREFIX/etc/config.site' if it exists. Or, you can set the + `CONFIG_SITE' environment variable to the location of the site script. + A warning: not all `configure' scripts look for a site script. + + Operation Controls + ================== + + `configure' recognizes the following options to control how it + operates. + + `--cache-file=FILE' + Use and save the results of the tests in FILE instead of + `./config.cache'. Set FILE to `/dev/null' to disable caching, for + debugging `configure'. + + `--help' + Print a summary of the options to `configure', and exit. + + `--quiet' + `--silent' + `-q' + Do not print messages saying which checks are being made. + + `--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + + `--version' + Print the version of Autoconf used to generate the `configure' + script, and exit. + + `configure' also accepts some other, not widely useful, options. + Index: llvm/lib/CodeGen/ELF/MANIFEST diff -c /dev/null llvm/lib/CodeGen/ELF/MANIFEST:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/MANIFEST Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,88 ---- + 25275 ./COPYING.LIB + 25791 ./ChangeLog + 7462 ./INSTALL + 5420 ./Makefile.in + 10211 ./README + 6 ./VERSION + 2657 ./acconfig.h + 7714 ./aclocal.m4 + 42037 ./config.guess + 3580 ./config.h.in + 30339 ./config.sub + 101907 ./configure + 9508 ./configure.in + 2186 ./install-sh + 4825 ./lib/32.fsize.c + 1584 ./lib/32.getehdr.c + 1584 ./lib/32.getphdr.c + 1692 ./lib/32.getshdr.c + 2216 ./lib/32.newehdr.c + 2779 ./lib/32.newphdr.c + 12010 ./lib/32.xlatetof.c + 13909 ./lib/64.xlatetof.c + 8155 ./lib/Makefile.in + 1147 ./lib/assert.c + 10319 ./lib/begin.c + 3594 ./lib/byteswap.h + 3965 ./lib/checksum.c + 1929 ./lib/cntl.c + 11520 ./lib/cook.c + 1030 ./lib/data.c + 22558 ./lib/elf_repl.h + 2939 ./lib/end.c + 2104 ./lib/errmsg.c + 1065 ./lib/errno.c + 6051 ./lib/errors.h + 8135 ./lib/ext_types.h + 1025 ./lib/fill.c + 2428 ./lib/flag.c + 5003 ./lib/gelf.h + 4139 ./lib/gelfehdr.c + 3953 ./lib/gelfphdr.c + 3745 ./lib/gelfshdr.c + 9483 ./lib/gelftrans.c + 1203 ./lib/getarhdr.c + 2381 ./lib/getarsym.c + 1124 ./lib/getbase.c + 3868 ./lib/getdata.c + 1381 ./lib/getident.c + 1477 ./lib/getscn.c + 1239 ./lib/hash.c + 2109 ./lib/input.c + 1116 ./lib/kind.c + 7490 ./lib/libelf.h + 1446 ./lib/memset.c + 1126 ./lib/ndxscn.c + 1585 ./lib/newdata.c + 3057 ./lib/newscn.c + 1384 ./lib/next.c + 1635 ./lib/nextscn.c + 5772 ./lib/nlist.c + 1405 ./lib/nlist.h + 5098 ./lib/opt.delscn.c + 12333 ./lib/private.h + 1314 ./lib/rand.c + 2570 ./lib/rawdata.c + 1501 ./lib/rawfile.c + 3250 ./lib/strptr.c + 2313 ./lib/swap64.c + 3752 ./lib/sys_elf.h.in + 25089 ./lib/update.c + 7643 ./lib/verdef.h + 1614 ./lib/verdef_32_tof.c + 1614 ./lib/verdef_32_tom.c + 1642 ./lib/verdef_64_tof.c + 1642 ./lib/verdef_64_tom.c + 7904 ./lib/verneed.h + 1283 ./lib/version.c + 2749 ./lib/x.movscn.c + 2898 ./lib/x.remscn.c + 619 ./mkinstalldirs + 4666 ./po/Makefile.in + 8684 ./po/de.gmo + 9027 ./po/de.msg + 10958 ./po/de.po + 2648 ./po/gmo2msg.c + 5959 ./po/libelf.pot + 10 ./po/stamp-po + 10 ./stamp-h.in Index: llvm/lib/CodeGen/ELF/Makefile.in diff -c /dev/null llvm/lib/CodeGen/ELF/Makefile.in:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/Makefile.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,177 ---- + # Makefile for libelf. + # Copyright (C) 1995 - 2001, 2003 Michael Riepe + # + # This library is free software; you can redistribute it and/or + # modify it under the terms of the GNU Library General Public + # License as published by the Free Software Foundation; either + # version 2 of the License, or (at your option) any later version. + # + # This library 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 + # Library General Public License for more details. + # + # You should have received a copy of the GNU Library General Public + # License along with this library; if not, write to the Free Software + # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + # @(#) $Id: Makefile.in,v 1.1 2005/06/22 06:35:57 reid Exp $ + + MV = mv -f + RM = rm -f + LN_S = @LN_S@ + + CC = @CC@ + CFLAGS = @CFLAGS@ + CPPFLAGS = @CPPFLAGS@ + LDFLAGS = @LDFLAGS@ + LIBS = @LIBS@ + + # no user serviceable parts below + + PACKAGE = @PACKAGE@ + VERSION = @VERSION@ + + SHELL = /bin/sh + @SET_MAKE@ + + srcdir = @srcdir@ + VPATH = @srcdir@ + + SUBDIRS = lib @POSUB@ + DISTSUBDIRS = lib po + + DISTFILES = \ + acconfig.h aclocal.m4 ChangeLog config.guess config.h.in \ + config.sub configure configure.in COPYING.LIB INSTALL install-sh \ + Makefile.in mkinstalldirs README stamp-h.in VERSION + + all: all-recursive all-local + check: check-recursive check-local + install: install-recursive install-local + uninstall: uninstall-recursive uninstall-local + mostlyclean: mostlyclean-recursive mostlyclean-local + clean: clean-recursive clean-local + distclean: distclean-recursive distclean-local + maintainer-clean: maintainer-clean-recursive maintainer-clean-local + + install-compat uninstall-compat: + cd lib && $(MAKE) $@ + + all-recursive check-recursive install-recursive uninstall-recursive \ + clean-recursive distclean-recursive mostlyclean-recursive \ + maintainer-clean-recursive: + @subdirs="$(SUBDIRS)"; for subdir in $$subdirs; do \ + target=`echo $@|sed 's,-recursive,,'`; \ + echo making $$target in $$subdir; \ + (cd $$subdir && $(MAKE) $$target) || exit 1; \ + done + + all-local: + + check-local: + + install-local: + + uninstall-local: + + mostlyclean-local: + $(RM) *~ core errlist + + clean-local: mostlyclean-local + + distclean-local: clean-local + $(RM) config.cache config.h config.log config.status stamp-h + $(RM) Makefile + + maintainer-clean-local: distclean-local + @echo "This command is intended for maintainers to use;" + @echo "it deletes files that may require special tools to rebuild." + $(RM) config.h.in configure stamp-dist + $(RM) -r $(distdir) + + # maintainer only + + MAINT = @MAINT@ + + distdir = $(PACKAGE)-$(VERSION) + DISTPERMS = --owner=root --group=root --numeric-owner + $(MAINT)dist: ./stamp-dist + $(MAINT)./stamp-dist: $(DISTFILES) + $(RM) -r $(distdir) + mkdir $(distdir) + files="$(DISTFILES)"; for file in $$files; do \ + ln $(srcdir)/$$file $(distdir) || \ + cp -p $(srcdir)/$$file $(distdir) || exit 1; \ + done + subdirs="$(DISTSUBDIRS)"; for subdir in $$subdirs; do \ + (cd $$subdir && $(MAKE) dist) || exit 1; \ + done + cd $(distdir) && \ + find . -type f ! -name MANIFEST -exec wc -c {} \; | \ + sort +1 >MANIFEST + -$(RM) $(distdir).tar.gz.bak $(PACKAGE).tar.gz + -$(MV) $(distdir).tar.gz $(distdir).tar.gz.bak + tar cvhfz $(distdir).tar.gz $(DISTPERMS) $(distdir) + $(LN_S) $(distdir).tar.gz $(PACKAGE).tar.gz + $(RM) stamp-dist && echo timestamp > stamp-dist + + $(MAINT)check-dist: + $(RM) -r disttest + mkdir disttest + @echo 'unset CC CFLAGS CPPFLAGS LDFLAGS LIBS' >disttest/config.site + @echo 'unset I_AM_THE_$(PACKAGE)_MAINTAINER' >>disttest/config.site + cd disttest && CONFIG_SITE=config.site ../$(distdir)/configure + $(MAKE) -C disttest + $(MAKE) -C disttest check + + tags: + rm -f tags + ctags -vst lib/*.c + ctags -ast lib/*.h + + # For the justification of the following Makefile rules, see node + # `Automatic Remaking' in GNU Autoconf documentation. + + $(MAINT)$(srcdir)/configure: $(srcdir)/configure.in $(srcdir)/aclocal.m4 + $(RM) $(srcdir)/configure + cd $(srcdir) && autoconf + + $(MAINT)$(srcdir)/config.h.in: $(srcdir)/stamp-h.in + $(MAINT)$(srcdir)/stamp-h.in: $(srcdir)/configure.in $(srcdir)/acconfig.h + $(RM) $(srcdir)/config.h.in + cd $(srcdir) && autoheader + cd $(srcdir) && $(RM) stamp-h.in && echo timestamp > stamp-h.in + + $(MAINT)config.h: stamp-h + $(MAINT)stamp-h: config.h.in config.status + CONFIG_FILES= CONFIG_HEADERS=config.h ./config.status + $(RM) stamp-h && echo timestamp > stamp-h + + $(MAINT)Makefile: Makefile.in config.status + CONFIG_FILES=$@ CONFIG_HEADERS= ./config.status + + $(MAINT)lib/Makefile: lib/Makefile.in config.status + CONFIG_FILES=$@ CONFIG_HEADERS= ./config.status + + $(MAINT)lib/sys_elf.h: lib/stamp-h + $(MAINT)lib/stamp-h: lib/sys_elf.h.in config.status + CONFIG_FILES= CONFIG_HEADERS=lib/sys_elf.h ./config.status + $(RM) lib/stamp-h && echo timestamp > lib/stamp-h + + $(MAINT)po/Makefile: po/Makefile.in config.status + CONFIG_FILES=$@ CONFIG_HEADERS= ./config.status + + RECHECK_FLAGS = CC='$(CC)' CPPFLAGS='$(CPPFLAGS)' \ + CFLAGS='$(CFLAGS)' LDFLAGS='$(LDFLAGS)' LIBS='$(LIBS)' + + $(MAINT)config.status: configure config.h.in VERSION + $(RECHECK_FLAGS) ./config.status --recheck + + $(MAINT)reconfig: + $(RM) config.cache + $(RECHECK_FLAGS) ./config.status --recheck + + # Tell versions [3.59,3.63) of GNU make not to export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. + .NOEXPORT: Index: llvm/lib/CodeGen/ELF/README diff -c /dev/null llvm/lib/CodeGen/ELF/README:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/README Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,244 ---- + This is the public release of libelf-0.8.5, a free ELF object + file access library. If you have problems with applications + that use libelf and work with the commercial (SVR4, Solaris) + version but not with this one, please contact me. + + IMPORTANT NOTE: If you have libelf-0.5.2 installed, you probably + have a file .../include/elf.h that contains the single line + ``#include ''. REMOVE THIS FILE BEFORE YOU RUN + configure. + + Installation is straightforward - the package is autoconf'ed. Just do + ``cd libelf-0.8.5; ./configure; make; make install''. Header files + will be installed in .../include/libelf/. If your system does not + provide its own versions of libelf.h, nlist.h or gelf.h, ``make + install'' will add the missing headers. If you prefer not to have + these files installed in /usr/include, use ``--disable-compat'' and + add ``-I /usr/include/libelf'' to your CFLAGS when compiling + libelf-based programs. + + Note to distribution makers: You can install libelf in a separate root + hierarchy by using the command ``make instroot=/my/root install''. + You should also use the ``--enable-compat'' configure option in that + case, or run ``make instroot=/my/root install-compat'' manually, to + install all the required header files. + + If you are running Linux with libc 5.* as the default C library, + and you plan to use the 64-bit functions, you must either use + ``-I.../include/libelf'', or remove /usr/include/libelf.h and use + ``--enable-compat'' when running configure. Libc 6.* (aka glibc2) + doesn't have its own , or . + + You need an ANSI/ISO C compiler to build libelf. Gcc is optimal. + + On some systems (in particular, Solaris and all variants of Linux), + ``make'' will try to build a shared library. If you run into problems + on your system, please pass ``--disable-shared'' to configure. + If you build a shared library and want it to be installed as + ``libelf-0.8.5.so'' rather than ``libelf.so.0.8.5'', please use + ``./configure --enable-gnu-names''. Other files, e.g. ``libelf.so'' and + ``libelf.so.0'' are NOT affected. + + Another configure option, ``--enable-debug'', adds debugging code to + libelf; if you don't run into problems, you will probably not need it. + + When creating an ELF shared library, it is possible to add references + to other shared libraries in the DYNAMIC section of the resulting + file. The make variable DEPSHLIBS contains a list of libraries to add. + It is set to ``-lc'' on Linux systems, and empty otherwise. To + override this setting, use something like ``make DEPSHLIBS="-la -lb"''. + For Linux, `-lc' is included automagically. + + NLS is available and enabled by default. To turn it off, pass the + ``--disable-nls'' option to configure. + + Libelf can use gettext or catgets for accessing message + catalogs. If gettext is available AND is part of libc (i.e. not + in a separate library), it will be used. Otherwise, configure + will look for catgets. If you have gettext in a separate + library and want to use it, you should pass the library's name + to configure, e.g. ``LIBS=-lintl ./configure''. Note that you + MUST link your libelf-based applications with -lintl then, + which is probably not what you want, or change the DEPSHLIBS variable + described above (in case you're building a shared library). + + If you have GNU gettext 0.10 installed on your system, and if GNU gettext + runs on top of the catgets interface (rather old Linux systems, using + libc5), configure will refuse to use it and use catgets instead. If you + absolutely want to use GNU gettext, go ahead and rebuild it (which is + IMHO a good idea in general in this case): + + cd .../gettext-0.10 + ac_cv_func_catgets=no ac_cv_func_gettext=no ./configure + make + make install + + After that, return to the libelf build directory, remove + config.cache, and start over. + + *** Large File Support (LFS) applications *** + + Some 32-bit systems support files that are larger than the address space + of the architecture. On these, the `off_t' data type may have 32 or + 64 bits, depending on the API you choose. Since off_t is also part of + the libelf API, in particular the Elf_Data and Elf_Arhdr structures, + an application compiled with large file support will need a version of + libelf that has also been compiled with LFS; otherwise, it won't work + correctly. Similarly, a program compiled without LFS needs a library + compiled without LFS. + + Note that libelf is currently unable to process large files on 32-bit + architectures, whether you compile it for LFS or not, for the simple + reason that the files won't fit into the processes' address space. + Therefore, libelf is compiled without LFS by default. It can of course + read and write ELF files for 64-bit architectures, but they will be + limited in length on a 32-bit system. + + You may compile libelf with large file support by setting CPPFLAGS at + configuration time: + + CPPFLAGS=`getconf LFS_CFLAGS` ./configure + + But I really, really recommend you don't, because it breaks binary + compatibility with existing libelf based applications. + + *** 64-bit support *** + + Starting with libelf-0.7.0, libelf also supports 64-bit ELF files. + This is enabled by default unless your system (or your compiler) does + not support 64-bit integers, or lacks 64-bit declarations in . + If you have problems building with 64-bit support, please do + + ./configure --disable-elf64 + + for the moment, and contact me. Please note that I haven't tested 64-bit + support much. There are still some unresolved problems, e.g. IRIX + uses different Elf64_Rel and Elf64_Rela structures (they replaced the + r_info member), and the enumeration values for Elf_Type differ from + the commercial (SVR4) implementation of libelf - they broke binary + compatibility for no good reason, and I'm not willing to follow their + footsteps. The result is that libelf-0.7.* ist upward compatible with + libelf-0.6.4 (as it should be) but INCOMPATIBLE WITH SVR4 LIBELF. If you + have both versions installed, you'd better make sure that you link with + the library that matches the you're #include'ing. + + *** Symbol Versioning *** + + Libelf >= 0.8.0 supports the data structures and definitions used for + symbol versioning on Solaris and Linux, in particular, the Elfxx_Verdef, + Elfxx_Verdaux, Elfxx_Verneed, Elfxx_Vernaux and Elfxx_Versym structures + and the SHT_XXX_verdef, SHT_XXX_verneed and SHT_XXX_versym section types + (where `xx' is either `32' or `64', and `XXX' is either `SUNW' or `GNU'). + Libelf now translates versioning sections to/from their external + representation properly (earlier versions left them in `raw' format, + with the data type set to ELF_T_BYTE). This may cause problems on + systems which use the same (OS-specific) section types for different + purposes. The configure program tries to figure out if your OS uses + versioning; if that check fails, you can use + + ./configure --disable-versioning + + to turn off versioning translation support. + + *** Missing things *** + + * There is no documentation. You can use the Solaris + manpages instead (available at http://docs.sun.com/). + The ELF file format is described in several places; + among them Suns "Linker and Libraries Guide" and the + "System V Application Binary Interface" documents; + http://www.caldera.com/developer/devspecs/gabi41.pdf and + http://www.caldera.com/developer/gabi/ are probably good + starting points. Processor-specific documentation is spread + across a number of `Processor Supplement' documents, one + for each architecture; you'll have to use a search engine to + find them. + + * The COFF file format is not understood. This is so obsolete + that it will probably never be implemented. + + * nlist(3) is incomplete; the n_type and n_sclass + members of struct nl are set to zero even if type + (that is, debug) information is available. + + * Libelf does not translate Solaris' `Move' and `Syminfo' + sections. You can read them using elf_getdata(), but you'll + only get raw (untranslated) bytes. + + Changes since 0.8.4: + + * elf_strptr() should now work more safely with fragmented + or badly formatted string tables. + + Changes since 0.8.3: + + * Fixed a bug in elf_update() that was introduced in 0.8.3. + + Changes since 0.8.2: + + * Should compile on MacOSX now. + + * Can read and write files with more than 65280 sections + + * Tries to handle 64-bit ELF files that use 8-byte hash table + entries. In particular, libelf tries to guess the data type in + elf_getdata(), and doesn't override sh_entsize in elf_update() + any longer. If you want the library to pick the entry size, + you must set its value to 0 before you call elf_update(). + + * No longer dumps core in elf_update() when a versioning section + has no data. Instead, it returns an error message. Note that + you're supposed to provide a valid d_buf for any section, unless + it's empty or has SHT_NOBITS type. + + * Building a shared library is now the default (if supported). + + Changes since 0.8.0: + + * Corrected typo in lib/{32,64}.xlatetof.c that sometimes + caused a compilation failure. + + * Use open(name, O_RDONLY|O_BINARY) in lib/nlist.c. + + Changes since 0.7.0: + + * I implemented the gelf_* interface, as found on Solaris. + I don't know whether it's compatible -- the Solaris manpage + isn't very specific, so I had to guess return values etc. in + some cases. + + * Added elf{32,64}_checksum (supposed to be compatible with + Solaris). + + * Added symbol versioning support. + + Changes since 0.6.4: + + * Fixed configure for IRIX systems + * Added check for truncated archive members + * Added check for misaligned SHDR/PHDR tables + * Support for building libelf together with GNU libc + * Added elf_memory(3) + * Added 64-bit support + + Changes since 0.5.2: + + * some bug fixes + * mmap support + * new directory layout + * There is a new function, elf_delscn(), that deletes + a section from an ELF file. It also adjusts the + sh_link and sh_info members in the section header + table, if (and ONLY if) the ELF standard indicates + that these values are section indices. References + to the deleted section will be cleared, so be careful. + * my email address has changed ;) + + Where to get libelf: + + ftp://ftp.ibiblio.org/pub/Linux/libs/ + http://www.stud.uni-hannover.de/~michael/software/ + + Michael "Tired" Riepe + + Index: llvm/lib/CodeGen/ELF/VERSION diff -c /dev/null llvm/lib/CodeGen/ELF/VERSION:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/VERSION Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1 ---- + 0.8.5 Index: llvm/lib/CodeGen/ELF/acconfig.h diff -c /dev/null llvm/lib/CodeGen/ELF/acconfig.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/acconfig.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,80 ---- + /* + acconfig.h - Special definitions for libelf, processed by autoheader. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: acconfig.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + /* Define if you want to include extra debugging code */ + #undef ENABLE_DEBUG + + /* Define if memmove() does not copy overlapping arrays correctly */ + #undef HAVE_BROKEN_MEMMOVE + + /* Define if you have the catgets function. */ + #undef HAVE_CATGETS + + /* Define if you have the gettext function. */ + #undef HAVE_GETTEXT + + /* Define if you have the memset function. */ + #undef HAVE_MEMSET + + /* Define if struct nlist is declared in or */ + #undef HAVE_STRUCT_NLIST_DECLARATION + + /* Define if Elf32_Dyn is declared in */ + #undef __LIBELF_NEED_LINK_H + + /* Define to `' or `' if one of them is present */ + #undef __LIBELF_HEADER_ELF_H + + /* Define if you want 64-bit support (and your system supports it) */ + #undef __LIBELF64 + + /* Define if you want 64-bit support, and are running IRIX */ + #undef __LIBELF64_IRIX + + /* Define if you want 64-bit support, and are running Linux */ + #undef __LIBELF64_LINUX + + /* Define if you want symbol versioning (and your system supports it) */ + #undef __LIBELF_SYMBOL_VERSIONS + + /* Define if symbol versioning uses Sun section type (SHT_SUNW_*) */ + #undef __LIBELF_SUN_SYMBOL_VERSIONS + + /* Define if symbol versioning uses GNU section types (SHT_GNU_*) */ + #undef __LIBELF_GNU_SYMBOL_VERSIONS + + /* Define to a 64-bit signed integer type if one exists */ + #undef __libelf_i64_t + + /* Define to a 64-bit unsigned integer type if one exists */ + #undef __libelf_u64_t + + /* Define to a 32-bit signed integer type if one exists */ + #undef __libelf_i32_t + + /* Define to a 32-bit unsigned integer type if one exists */ + #undef __libelf_u32_t + + /* Define to a 16-bit signed integer type if one exists */ + #undef __libelf_i16_t + + /* Define to a 16-bit unsigned integer type if one exists */ + #undef __libelf_u16_t Index: llvm/lib/CodeGen/ELF/aclocal.m4 diff -c /dev/null llvm/lib/CodeGen/ELF/aclocal.m4:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/aclocal.m4 Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,294 ---- + # Local additions to Autoconf macros. + # Copyright (C) 1995 - 2003 Michael Riepe + + # @(#) $Id: aclocal.m4,v 1.1 2005/06/22 06:35:57 reid Exp $ + + AC_PREREQ(2.13) + + dnl mr_PACKAGE(package-name) + AC_DEFUN(mr_PACKAGE, [changequote(<<, >>)dnl + define(<>, <>translit($1, [a-z-], [A-Z_])<<_MAINTAINER>>)dnl + changequote([, ])dnl + PACKAGE=$1 + VERSION=`cat $srcdir/VERSION` + AC_SUBST(PACKAGE) + AC_SUBST(VERSION) + AC_ARG_ENABLE(maintainer-mode, + [ --enable-maintainer-mode + enable maintainer-specific make rules (default: no)], + [mr_enable_maintainer_mode="$enableval"], + [mr_enable_maintainer_mode="${mr_MAINT-no}"]) + if test x"$mr_enable_maintainer_mode" = x"yes"; then + MAINT= + else + MAINT='maintainer-only-' + fi + AC_SUBST(MAINT) + undefine(<>)dnl + ]) + + AC_DEFUN(mr_ENABLE_NLS, [ + AC_PROVIDE([$0]) + + # Needed for `make dist' even if NLS is disabled. + GMOFILES= + MSGFILES= + POFILES= + for mr_lang in $ALL_LINGUAS; do + GMOFILES="$GMOFILES $mr_lang.gmo" + MSGFILES="$MSGFILES $mr_lang.msg" + POFILES="$POFILES $mr_lang.po" + done + AC_SUBST(GMOFILES) + AC_SUBST(MSGFILES) + AC_SUBST(POFILES) + + AC_MSG_CHECKING([whether NLS is requested]) + AC_ARG_ENABLE(nls, + [ --enable-nls use Native Language Support (default: yes)], + [mr_enable_nls="$enableval"], + [mr_enable_nls=yes]) + AC_MSG_RESULT($mr_enable_nls) + + CATOBJEXT= + INSTOBJEXT= + localedir= + if test "$mr_enable_nls" = yes; then + mr_PATH=`echo ":$PATH" | sed -e 's,:[^:]*openwin[^:]*,,g' -e 's,^:,,'` + AC_CACHE_CHECK([for gettext], + mr_cv_func_gettext, [ + AC_TRY_LINK([#include ], + [char *s = gettext(""); return 0], + [mr_cv_func_gettext=yes], + [mr_cv_func_gettext=no]) + ]) + if test "$mr_cv_func_gettext" = yes; then + AC_PATH_PROG(MSGFMT, msgfmt, no, $mr_PATH) + if test "$MSGFMT" != no; then + AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT, $mr_PATH) + AC_PATH_PROG(XGETTEXT, xgettext, xgettext, $mr_PATH) + AC_CACHE_CHECK([for GNU gettext], + mr_cv_gnu_gettext, [ + AC_TRY_LINK([], + [extern int _nl_msg_cat_cntr; return _nl_msg_cat_cntr], + [mr_cv_gnu_gettext=yes], + [mr_cv_gnu_gettext=no]) + ]) + if test "$mr_cv_gnu_gettext" = yes; then + AC_CACHE_CHECK([for losing catgets-based GNU gettext], + mr_cv_catgets_based_gettext, [ + AC_TRY_LINK([], + [extern int _msg_tbl_length; return _msg_tbl_length], + [mr_cv_catgets_based_gettext=yes], + [mr_cv_catgets_based_gettext=no]) + ]) + if test "$mr_cv_catgets_based_gettext" = yes; then + # This loses completely. Turn it off and use catgets. + LIBS=`echo $LIBS | sed 's,-lintl,,g'` + mr_cv_func_gettext=no + else + # Is there a better test for this case? + AC_CACHE_CHECK([for pure GNU gettext], + mr_cv_pure_gnu_gettext, [ + AC_TRY_LINK([], + [extern int gettext(); return gettext()], + [mr_cv_pure_gnu_gettext=yes], + [mr_cv_pure_gnu_gettext=no]) + ]) + if test "$mr_cv_pure_gnu_gettext" = yes; then + CATOBJEXT=.gmo + localedir='$(prefix)/share/locale' + else + CATOBJEXT=.mo + localedir='$(prefix)/lib/locale' + fi + INSTOBJEXT=.mo + fi + else + # System provided gettext + CATOBJEXT=.mo + INSTOBJEXT=.mo + localedir='$(prefix)/lib/locale' + fi + else + # Gettext but no msgfmt. Try catgets. + mr_cv_func_gettext=no + fi + fi + if test "$mr_cv_func_gettext" = yes; then + AC_DEFINE(HAVE_GETTEXT) + else + AC_CACHE_CHECK([for catgets], mr_cv_func_catgets, [ + AC_TRY_LINK([#include ], + [catgets(catopen("",0),0,0,"");return 0;], + [mr_cv_func_catgets=yes], + [mr_cv_func_catgets=no]) + ]) + if test "$mr_cv_func_catgets" = yes; then + AC_PATH_PROG(GENCAT, gencat, no, $mr_PATH) + if test "$GENCAT" != no; then + AC_DEFINE(HAVE_CATGETS) + AC_PATH_PROG(GMSGFMT, [gmsgfmt msgfmt], msgfmt, $mr_PATH) + AC_PATH_PROG(XGETTEXT, xgettext, xgettext, $mr_PATH) + CATOBJEXT=.cat + INSTOBJEXT=.cat + localedir='$(prefix)/lib/locale' + fi + else + AC_MSG_WARN([no NLS support, disabled]) + mr_enable_nls=no + fi + fi + fi + AC_SUBST(CATOBJEXT) + AC_SUBST(INSTOBJEXT) + AC_SUBST(localedir) + + POSUB= + CATALOGS= + if test "$mr_enable_nls" = yes; then + AC_MSG_CHECKING([for catalogs to be installed]) + mr_linguas= + for mr_lang in ${LINGUAS=$ALL_LINGUAS}; do + case " $ALL_LINGUAS " in + *" $mr_lang "*) + mr_linguas="$mr_linguas$mr_lang " + CATALOGS="$CATALOGS $mr_lang$CATOBJEXT" + ;; + esac + done + AC_MSG_RESULT($mr_linguas) + POSUB=po + fi + AC_SUBST(CATALOGS) + AC_SUBST(POSUB) + ]) + + AC_DEFUN(mr_TARGET_ELF, [ + AC_PROVIDE([$0]) + AC_CACHE_CHECK([for native ELF system], + mr_cv_target_elf, + [AC_TRY_RUN(changequote(<<, >>)dnl + <<#include + int + main(int argc, char **argv) { + char buf[BUFSIZ]; + FILE *fp; + int n; + + if ((fp = fopen(*argv, "r")) == NULL) { + exit(1); + } + n = fread(buf, 1, sizeof(buf), fp); + if (n >= 52 + && buf[0] == '\177' + && buf[1] == 'E' + && buf[2] == 'L' + && buf[3] == 'F') { + exit(0); + } + exit(1); + }>>, changequote([, ])dnl + mr_cv_target_elf=yes, + mr_cv_target_elf=no, + mr_cv_target_elf=no)])]) + + AC_DEFUN(mr_ENABLE_SHARED, [ + AC_PROVIDE([$0]) + PICFLAGS= + SHLIB_SFX= + SHLINK_SFX= + SONAME_SFX= + LINK_SHLIB= + INSTALL_SHLIB= + DEPSHLIBS= + AC_MSG_CHECKING([whether to build a shared library]) + AC_ARG_ENABLE(shared, + [ --enable-shared build shared library (default: yes)], + [mr_enable_shared="$enableval"], + [mr_enable_shared=yes]) + AC_MSG_RESULT($mr_enable_shared) + if test "$mr_enable_shared" = yes; then + AC_MSG_CHECKING([whether GNU naming conventions are requested]) + AC_ARG_ENABLE(gnu_names, + [ --enable-gnu-names use GNU library naming conventions (default: no)], + [mr_enable_gnu_names="$enableval"], + [mr_enable_gnu_names=no]) + AC_MSG_RESULT($mr_enable_gnu_names) + AC_REQUIRE([AC_CANONICAL_HOST]) + AC_REQUIRE([AC_PROG_CC]) + AC_PATH_PROG(LD, ld, ld) + case "$host" in + *-linux*|*-gnu*) + if test "$GCC" = yes; then + mr_TARGET_ELF + if test "$mr_cv_target_elf" = yes; then + PICFLAGS='-fPIC -DPIC' + if test "$mr_enable_gnu_names" = yes + then + SHLIB_SFX='-$(VERSION).so' + else + SHLIB_SFX='.so.$(VERSION)' + fi + SHLINK_SFX='.so' + SONAME_SFX='.so.$(MAJOR)' + LINK_SHLIB='$(CC) -shared -Wl,-soname,$(SONAME)' + INSTALL_SHLIB='$(INSTALL_PROGRAM)' + DEPSHLIBS='-lc' + else + AC_MSG_WARN([shared libraries not supported for $host]) + mr_enable_shared=no + fi + else + AC_MSG_WARN([GNU CC required for building shared libraries]) + mr_enable_shared=no + fi + ;; + sparc-sun-solaris2*) + if test "$GCC" = yes; then + PICFLAGS='-fPIC -DPIC' + else + PICFLAGS='-K PIC -DPIC' + fi + if test "$mr_enable_gnu_names" = yes + then + SHLIB_SFX='-$(MAJOR).so' + else + SHLIB_SFX='.so.$(MAJOR)' + fi + SONAME_SFX='.so.$(MAJOR)' + SHLINK_SFX='.so' + LINK_SHLIB='$(LD) -G -z text -h $(SONAME)' + INSTALL_SHLIB='$(INSTALL_PROGRAM)' + ;; + *) + AC_MSG_WARN([shared libraries not supported for $host]) + mr_enable_shared=no + ;; + esac + else + mr_enable_shared=no + fi + AC_SUBST(PICFLAGS) + AC_SUBST(SHLIB_SFX) + AC_SUBST(SHLINK_SFX) + AC_SUBST(SONAME_SFX) + AC_SUBST(LINK_SHLIB) + AC_SUBST(INSTALL_SHLIB) + AC_SUBST(DEPSHLIBS) + DO_SHLIB="$mr_enable_shared" + AC_SUBST(DO_SHLIB) + ]) + + AC_DEFUN(mr_ENABLE_DEBUG, [ + AC_PROVIDE([$0]) + AC_ARG_ENABLE(debug, + [ --enable-debug include extra debugging code (default: no)], + [mr_enable_debug="$enableval"], + [mr_enable_debug=no]) + if test "$mr_enable_debug" = yes; then + AC_DEFINE(ENABLE_DEBUG) + fi + ]) + + # vi: set ts=8 sw=2 : Index: llvm/lib/CodeGen/ELF/config.guess diff -c /dev/null llvm/lib/CodeGen/ELF/config.guess:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/config.guess Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,1407 ---- + #! /bin/sh + # Attempt to guess a canonical system name. + # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + # 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + timestamp='2003-07-02' + + # This file is free software; you can redistribute it and/or modify it + # under the terms of the GNU General Public License as published by + # the Free Software Foundation; either version 2 of the License, or + # (at your option) any later version. + # + # 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. + # + # As a special exception to the GNU General Public License, if you + # distribute this file as part of a program that contains a + # configuration script generated by Autoconf, you may include it under + # the same distribution terms that you use for the rest of that program. + + # Originally written by Per Bothner . + # Please send patches to . Submit a context + # diff and a properly formatted ChangeLog entry. + # + # This script attempts to guess a canonical system name similar to + # config.sub. If it succeeds, it prints the system name on stdout, and + # exits with 0. Otherwise, it exits with 1. + # + # The plan is that this can be called by configure scripts if you + # don't specify an explicit build system type. + + me=`echo "$0" | sed -e 's,.*/,,'` + + usage="\ + Usage: $0 [OPTION] + + Output the configuration name of the system \`$me' is run on. + + Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + + Report bugs and patches to ." + + version="\ + GNU config.guess ($timestamp) + + Originally written by Per Bothner. + Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. + + This is free software; see the source for copying conditions. There is NO + warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + + help=" + Try \`$me --help' for more information." + + # Parse command line + while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac + done + + if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 + fi + + trap 'exit 1' 1 2 15 + + # CC_FOR_BUILD -- compiler used by this script. Note that the use of a + # compiler to aid in system detection is discouraged as it requires + # temporary files to be created and, as you can see below, it is a + # headache to deal with in a portable fashion. + + # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still + # use `HOST_CC' if defined, but it is deprecated. + + # Portable tmp directory creation inspired by the Autoconf team. + + set_cc_for_build=' + trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; + trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; + : ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; + dummy=$tmp/dummy ; + tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; + case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; + esac ;' + + # This is needed to find uname on a Pyramid OSx when run in the BSD universe. + # (ghazi at noc.rutgers.edu 1994-08-24) + if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH + fi + + UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown + UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown + UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown + UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + + # Note: order is significant - the case branches are not exclusive. + + case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep __ELF__ >/dev/null + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit 0 ;; + amiga:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + arc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + hp300:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mac68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + macppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme88k:OpenBSD:*:*) + echo m88k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvmeppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + pmax:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sgi:OpenBSD:*:*) + echo mipseb-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sun3:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + wgrisc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + *:OpenBSD:*:*) + echo ${UNAME_MACHINE}-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + alpha:OSF1:*:*) + if test $UNAME_RELEASE = "V4.0"; then + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + fi + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + exit 0 ;; + Alpha*:OpenVMS:*:*) + echo alpha-hp-vms + exit 0 ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit 0 ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit 0 ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit 0;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit 0 ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit 0 ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit 0 ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit 0;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit 0;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee at wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit 0 ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit 0 ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit 0 ;; + DRS?6000:UNIX_SV:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7 && exit 0 ;; + esac ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + i86pc:SunOS:5.*:*) + echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit 0 ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit 0 ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit 0 ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit 0 ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit 0 ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit 0 ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit 0 ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit 0 ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit 0 ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit 0 ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #ifdef __cplusplus + #include /* for printf() prototype */ + int main (int argc, char *argv[]) { + #else + int main (argc, argv) int argc; char *argv[]; { + #endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } + EOF + $CC_FOR_BUILD -o $dummy $dummy.c \ + && $dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \ + && exit 0 + echo mips-mips-riscos${UNAME_RELEASE} + exit 0 ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit 0 ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit 0 ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit 0 ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit 0 ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit 0 ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit 0 ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit 0 ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit 0 ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit 0 ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit 0 ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit 0 ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit 0 ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit 0 ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } + EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo rs6000-ibm-aix3.2.5 + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit 0 ;; + *:AIX:*:[45]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit 0 ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit 0 ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit 0 ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit 0 ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit 0 ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit 0 ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit 0 ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } + EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + # avoid double evaluation of $set_cc_for_build + test -n "$CC_FOR_BUILD" || eval $set_cc_for_build + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E -) | grep __LP64__ >/dev/null + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit 0 ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit 0 ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } + EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo unknown-hitachi-hiuxwe2 + exit 0 ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit 0 ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit 0 ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit 0 ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit 0 ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit 0 ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit 0 ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit 0 ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit 0 ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit 0 ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit 0 ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit 0 ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + *:UNICOS/mp:*:*) + echo nv1-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit 0 ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit 0 ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:FreeBSD:*:*|*:GNU/FreeBSD:*:*) + # Determine whether the default compiler uses glibc. + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #if __GLIBC__ >= 2 + LIBC=gnu + #else + LIBC= + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + # GNU/FreeBSD systems have a "k" prefix to indicate we are using + # FreeBSD's kernel, but not the complete OS. + case ${LIBC} in gnu) kernel_only='k' ;; esac + echo ${UNAME_MACHINE}-unknown-${kernel_only}freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`${LIBC:+-$LIBC} + exit 0 ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit 0 ;; + i*:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit 0 ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit 0 ;; + x86:Interix*:[34]*) + echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//' + exit 0 ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit 0 ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit 0 ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit 0 ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit 0 ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + *:GNU:*:*) + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit 0 ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit 0 ;; + arm*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + cris:Linux:*:*) + echo cris-axis-linux-gnu + exit 0 ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + mips:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips + #undef mipsel + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mipsel + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips + #else + CPU= + #endif + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips64 + #undef mips64el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mips64el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips64 + #else + CPU= + #endif + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-gnu + exit 0 ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-gnu + exit 0 ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null + if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi + echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} + exit 0 ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-gnu ;; + PA8*) echo hppa2.0-unknown-linux-gnu ;; + *) echo hppa-unknown-linux-gnu ;; + esac + exit 0 ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-gnu + exit 0 ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux + exit 0 ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + x86_64:Linux:*:*) + echo x86_64-unknown-linux-gnu + exit 0 ;; + i*86:Linux:*:*) + # The BFD linker knows what the default object file format is, so + # first see if it will tell us. cd to the root directory to prevent + # problems with other programs or directories called `ld' in the path. + # Set LC_ALL=C to ensure ld outputs messages in English. + ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ + | sed -ne '/supported targets:/!d + s/[ ][ ]*/ /g + s/.*supported targets: *// + s/ .*// + p'` + case "$ld_supported_targets" in + elf32-i386) + TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" + ;; + a.out-i386-linux) + echo "${UNAME_MACHINE}-pc-linux-gnuaout" + exit 0 ;; + coff-i386) + echo "${UNAME_MACHINE}-pc-linux-gnucoff" + exit 0 ;; + "") + # Either a pre-BFD a.out linker (linux-gnuoldld) or + # one that does not give us useful --help. + echo "${UNAME_MACHINE}-pc-linux-gnuoldld" + exit 0 ;; + esac + # Determine whether the default compiler is a.out or elf + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #ifdef __ELF__ + # ifdef __GLIBC__ + # if __GLIBC__ >= 2 + LIBC=gnu + # else + LIBC=gnulibc1 + # endif + # else + LIBC=gnulibc1 + # endif + #else + #ifdef __INTEL_COMPILER + LIBC=gnu + #else + LIBC=gnuaout + #endif + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + test x"${LIBC}" != x && echo "${UNAME_MACHINE}-pc-linux-${LIBC}" && exit 0 + test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0 + ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit 0 ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit 0 ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit 0 ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit 0 ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit 0 ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit 0 ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit 0 ;; + i*86:*:5:[78]*) + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit 0 ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit 0 ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i386. + echo i386-pc-msdosdjgpp + exit 0 ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit 0 ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit 0 ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit 0 ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit 0 ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit 0 ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit 0 ;; + M68*:*:R3V[567]*:*) + test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; + 3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4.3${OS_REL} && exit 0 + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4 && exit 0 ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit 0 ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit 0 ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit 0 ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit 0 ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit 0 ;; + *:*:*:FTX*) + # From seanf at swdc.stratus.com. + echo i860-stratus-sysv4 + exit 0 ;; + *:VOS:*:*) + # From Paul.Green at stratus.com. + echo hppa1.1-stratus-vos + exit 0 ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit 0 ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit 0 ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit 0 ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit 0 ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit 0 ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit 0 ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit 0 ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Darwin:*:*) + case `uname -p` in + *86) UNAME_PROCESSOR=i686 ;; + powerpc) UNAME_PROCESSOR=powerpc ;; + esac + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit 0 ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit 0 ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit 0 ;; + NSR-[DGKLNPTVW]:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit 0 ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit 0 ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit 0 ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit 0 ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit 0 ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit 0 ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit 0 ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit 0 ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit 0 ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit 0 ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit 0 ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit 0 ;; + esac + + #echo '(No uname command or uname output not recognized.)' 1>&2 + #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 + + eval $set_cc_for_build + cat >$dummy.c < + # include + #endif + main () + { + #if defined (sony) + #if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); + #else + #include + printf ("m68k-sony-newsos%s\n", + #ifdef NEWSOS4 + "4" + #else + "" + #endif + ); exit (0); + #endif + #endif + + #if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix"); exit (0); + #endif + + #if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); + #endif + + #if defined (NeXT) + #if !defined (__ARCHITECTURE__) + #define __ARCHITECTURE__ "m68k" + #endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); + #endif + + #if defined (MULTIMAX) || defined (n16) + #if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); + #else + #if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); + #else + printf ("ns32k-encore-bsd\n"); exit (0); + #endif + #endif + #endif + + #if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); + #endif + + #if defined (sequent) + #if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); + #endif + #if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); + #endif + #endif + + #if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + + #endif + + #if defined (vax) + # if !defined (ultrix) + # include + # if defined (BSD) + # if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); + # else + # if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); + # else + printf ("vax-dec-bsd\n"); exit (0); + # endif + # endif + # else + printf ("vax-dec-bsd\n"); exit (0); + # endif + # else + printf ("vax-dec-ultrix\n"); exit (0); + # endif + #endif + + #if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); + #endif + + exit (1); + } + EOF + + $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && $dummy && exit 0 + + # Apollos put the system type in the environment. + + test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; } + + # Convex versions that predate uname can use getsysinfo(1) + + if [ -x /usr/convex/getsysinfo ] + then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit 0 ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + c34*) + echo c34-convex-bsd + exit 0 ;; + c38*) + echo c38-convex-bsd + exit 0 ;; + c4*) + echo c4-convex-bsd + exit 0 ;; + esac + fi + + cat >&2 < in order to provide the needed + information to handle your system. + + config.guess timestamp = $timestamp + + uname -m = `(uname -m) 2>/dev/null || echo unknown` + uname -r = `(uname -r) 2>/dev/null || echo unknown` + uname -s = `(uname -s) 2>/dev/null || echo unknown` + uname -v = `(uname -v) 2>/dev/null || echo unknown` + + /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` + /bin/uname -X = `(/bin/uname -X) 2>/dev/null` + + hostinfo = `(hostinfo) 2>/dev/null` + /bin/universe = `(/bin/universe) 2>/dev/null` + /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` + /bin/arch = `(/bin/arch) 2>/dev/null` + /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` + /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + + UNAME_MACHINE = ${UNAME_MACHINE} + UNAME_RELEASE = ${UNAME_RELEASE} + UNAME_SYSTEM = ${UNAME_SYSTEM} + UNAME_VERSION = ${UNAME_VERSION} + EOF + + exit 1 + + # Local variables: + # eval: (add-hook 'write-file-hooks 'time-stamp) + # time-stamp-start: "timestamp='" + # time-stamp-format: "%:y-%02m-%02d" + # time-stamp-end: "'" + # End: Index: llvm/lib/CodeGen/ELF/config.h.in diff -c /dev/null llvm/lib/CodeGen/ELF/config.h.in:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/config.h.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,136 ---- + /* config.h.in. Generated automatically from configure.in by autoheader. */ + + /* Define to empty if the keyword does not work. */ + #undef const + + /* Define if you have a working `mmap' system call. */ + #undef HAVE_MMAP + + /* Define to `long' if doesn't define. */ + #undef off_t + + /* Define to `unsigned' if doesn't define. */ + #undef size_t + + /* Define if you have the ANSI C header files. */ + #undef STDC_HEADERS + + /* Define if you want to include extra debugging code */ + #undef ENABLE_DEBUG + + /* Define if memmove() does not copy overlapping arrays correctly */ + #undef HAVE_BROKEN_MEMMOVE + + /* Define if you have the catgets function. */ + #undef HAVE_CATGETS + + /* Define if you have the gettext function. */ + #undef HAVE_GETTEXT + + /* Define if you have the memset function. */ + #undef HAVE_MEMSET + + /* Define if struct nlist is declared in or */ + #undef HAVE_STRUCT_NLIST_DECLARATION + + /* Define if Elf32_Dyn is declared in */ + #undef __LIBELF_NEED_LINK_H + + /* Define to `' or `' if one of them is present */ + #undef __LIBELF_HEADER_ELF_H + + /* Define if you want 64-bit support (and your system supports it) */ + #undef __LIBELF64 + + /* Define if you want 64-bit support, and are running IRIX */ + #undef __LIBELF64_IRIX + + /* Define if you want 64-bit support, and are running Linux */ + #undef __LIBELF64_LINUX + + /* Define if you want symbol versioning (and your system supports it) */ + #undef __LIBELF_SYMBOL_VERSIONS + + /* Define if symbol versioning uses Sun section type (SHT_SUNW_*) */ + #undef __LIBELF_SUN_SYMBOL_VERSIONS + + /* Define if symbol versioning uses GNU section types (SHT_GNU_*) */ + #undef __LIBELF_GNU_SYMBOL_VERSIONS + + /* Define to a 64-bit signed integer type if one exists */ + #undef __libelf_i64_t + + /* Define to a 64-bit unsigned integer type if one exists */ + #undef __libelf_u64_t + + /* Define to a 32-bit signed integer type if one exists */ + #undef __libelf_i32_t + + /* Define to a 32-bit unsigned integer type if one exists */ + #undef __libelf_u32_t + + /* Define to a 16-bit signed integer type if one exists */ + #undef __libelf_i16_t + + /* Define to a 16-bit unsigned integer type if one exists */ + #undef __libelf_u16_t + + /* The number of bytes in a int. */ + #undef SIZEOF_INT + + /* The number of bytes in a long. */ + #undef SIZEOF_LONG + + /* The number of bytes in a long long. */ + #undef SIZEOF_LONG_LONG + + /* The number of bytes in a short. */ + #undef SIZEOF_SHORT + + /* Define if you have the ftruncate function. */ + #undef HAVE_FTRUNCATE + + /* Define if you have the getpagesize function. */ + #undef HAVE_GETPAGESIZE + + /* Define if you have the memcmp function. */ + #undef HAVE_MEMCMP + + /* Define if you have the memcpy function. */ + #undef HAVE_MEMCPY + + /* Define if you have the memmove function. */ + #undef HAVE_MEMMOVE + + /* Define if you have the memset function. */ + #undef HAVE_MEMSET + + /* Define if you have the header file. */ + #undef HAVE_AR_H + + /* Define if you have the header file. */ + #undef HAVE_ELF_H + + /* Define if you have the header file. */ + #undef HAVE_FCNTL_H + + /* Define if you have the header file. */ + #undef HAVE_GELF_H + + /* Define if you have the header file. */ + #undef HAVE_LIBELF_H + + /* Define if you have the header file. */ + #undef HAVE_LINK_H + + /* Define if you have the header file. */ + #undef HAVE_NLIST_H + + /* Define if you have the header file. */ + #undef HAVE_SYS_ELF_H + + /* Define if you have the header file. */ + #undef HAVE_SYS_LINK_H + + /* Define if you have the header file. */ + #undef HAVE_UNISTD_H Index: llvm/lib/CodeGen/ELF/config.sub diff -c /dev/null llvm/lib/CodeGen/ELF/config.sub:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/config.sub Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,1505 ---- + #! /bin/sh + # Configuration validation subroutine script. + # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + # 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + timestamp='2003-07-17' + + # This file is (in principle) common to ALL GNU software. + # The presence of a machine in this file suggests that SOME GNU software + # can handle that machine. It does not imply ALL GNU software can. + # + # This file is free software; you can redistribute it and/or modify + # it under the terms of the GNU General Public License as published by + # the Free Software Foundation; either version 2 of the License, or + # (at your option) any later version. + # + # 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. + + # As a special exception to the GNU General Public License, if you + # distribute this file as part of a program that contains a + # configuration script generated by Autoconf, you may include it under + # the same distribution terms that you use for the rest of that program. + + # Please send patches to . Submit a context + # diff and a properly formatted ChangeLog entry. + # + # Configuration subroutine to validate and canonicalize a configuration type. + # Supply the specified configuration type as an argument. + # If it is invalid, we print an error message on stderr and exit with code 1. + # Otherwise, we print the canonical config type on stdout and succeed. + + # This file is supposed to be the same for all GNU packages + # and recognize all the CPU types, system types and aliases + # that are meaningful with *any* GNU software. + # Each package is responsible for reporting which valid configurations + # it does not support. The user should be able to distinguish + # a failure to support a valid configuration from a meaningless + # configuration. + + # The goal of this file is to map all the various variations of a given + # machine specification into a single specification in the form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM + # or in some cases, the newer four-part form: + # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM + # It is wrong to echo any other type of specification. + + me=`echo "$0" | sed -e 's,.*/,,'` + + usage="\ + Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + + Canonicalize a configuration name. + + Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + + Report bugs and patches to ." + + version="\ + GNU config.sub ($timestamp) + + Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. + + This is free software; see the source for copying conditions. There is NO + warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + + help=" + Try \`$me --help' for more information." + + # Parse command line + while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit 0;; + + * ) + break ;; + esac + done + + case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; + esac + + # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). + # Here we must recognize all the valid KERNEL-OS combinations. + maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` + case $maybe_os in + nto-qnx* | linux-gnu* | kfreebsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; + esac + + ### Let's recognize common machines as not being operating systems so + ### that things like config.sub decstation-3100 work. We also + ### recognize some manufacturers as not being operating systems, so we + ### can provide default operating systems below. + case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis) + os= + basic_machine=$1 + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + esac + + # Decode aliases for certain CPU-COMPANY combinations. + case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \ + | c4x | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | m32r | m68000 | m68k | m88k | mcore \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64vr | mips64vrel \ + | mips64orion | mips64orionel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | msp430 \ + | ns16k | ns32k \ + | openrisc | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ + | pyramid \ + | sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv9 | sparcv9b \ + | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ + | v850 | v850e \ + | we32k \ + | x86 | xscale | xstormy16 | xtensa \ + | z8k) + basic_machine=$basic_machine-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12) + # Motorola 68HC11/12. + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* \ + | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ + | clipper-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | m32r-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | mcore-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipstx39-* | mipstx39el-* \ + | msp430-* \ + | none-* | np1-* | nv1-* | ns16k-* | ns32k-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ + | pyramid-* \ + | romp-* | rs6000-* \ + | sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \ + | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \ + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ + | v850-* | v850e-* | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \ + | xtensa-* \ + | ymp-* \ + | z8k-*) + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + crds | unos) + basic_machine=m68k-crds + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; + # I'm not sure what "Sysv32" means. Should this be sysv3.2? + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + mingw32) + basic_machine=i386-pc + os=-mingw32 + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + mmix*) + basic_machine=mmix-knuth + os=-mmixware + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + nv1) + basic_machine=nv1-cray + os=-unicosmp + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + or32 | or32-*) + basic_machine=or32-unknown + os=-coff + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc) basic_machine=powerpc-unknown + ;; + ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tic54x | c54x*) + basic_machine=tic54x-unknown + os=-coff + ;; + tic55x | c55x*) + basic_machine=tic55x-unknown + os=-coff + ;; + tic6x | c6x*) + basic_machine=tic6x-unknown + os=-coff + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + + # Here we handle the default manufacturer of certain CPU types. It is in + # some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh3 | sh4 | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparc | sparcv9 | sparcv9b) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + esac + + # Here we canonicalize certain aliases for manufacturers. + case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; + esac + + # Decode manufacturer-specific aliases for certain operating systems. + + if [ x"$os" != x"" ] + then + case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -netbsd* | -openbsd* | -kfreebsd* | -freebsd* | -riscix* \ + | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* \ + | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -kaos*) + os=-kaos + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; + esac + else + + # Here we handle the default operating systems that come with various machines. + # The value should be what the vendor currently ships out the door with their + # machine or put another way, the most popular os provided with the machine. + + # Note that if you're going to try to match "-MANUFACTURER" here (say, + # "-sun"), then you have to tell the case statement up towards the top + # that MANUFACTURER isn't an operating system. Otherwise, code above + # will signal an error saying that MANUFACTURER isn't an operating + # system, and we'll never get to this point. + + case $basic_machine in + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + # This also exists in the configure program, but was not the + # default. + # os=-sunos4 + ;; + m68*-cisco) + os=-aout + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-ibm) + os=-aix + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; + esac + fi + + # Here we handle the case where we know the os, and the CPU type, but not the + # manufacturer. We pick the logical manufacturer. + vendor=unknown + case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; + esac + + echo $basic_machine$os + exit 0 + + # Local variables: + # eval: (add-hook 'write-file-hooks 'time-stamp) + # time-stamp-start: "timestamp='" + # time-stamp-format: "%:y-%02m-%02d" + # time-stamp-end: "'" + # End: Index: llvm/lib/CodeGen/ELF/configure diff -c /dev/null llvm/lib/CodeGen/ELF/configure:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/configure Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,3579 ---- + #! /bin/sh + + # Guess values for system-dependent variables and create Makefiles. + # Generated automatically using autoconf version 2.13 + # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc. + # + # This configure script is free software; the Free Software Foundation + # gives unlimited permission to copy, distribute and modify it. + + # Defaults: + ac_help= + ac_default_prefix=/usr/local + # Any additions from configure.in: + ac_help="$ac_help + --enable-maintainer-mode + enable maintainer-specific make rules (default: no)" + ac_help="$ac_help + --enable-compat install , and (default: auto)" + ac_help="$ac_help + --enable-elf64 compile in 64-bit support (default: auto)" + ac_help="$ac_help + --enable-versioning compile in versioning support (default: auto)" + ac_help="$ac_help + --enable-nls use Native Language Support (default: yes)" + ac_help="$ac_help + --enable-shared build shared library (default: yes)" + ac_help="$ac_help + --enable-gnu-names use GNU library naming conventions (default: no)" + ac_help="$ac_help + --enable-debug include extra debugging code (default: no)" + + # Initialize some variables set by options. + # The variables have the same names as the options, with + # dashes changed to underlines. + build=NONE + cache_file=./config.cache + exec_prefix=NONE + host=NONE + no_create= + nonopt=NONE + no_recursion= + prefix=NONE + program_prefix=NONE + program_suffix=NONE + program_transform_name=s,x,x, + silent= + site= + srcdir= + target=NONE + verbose= + x_includes=NONE + x_libraries=NONE + bindir='${exec_prefix}/bin' + sbindir='${exec_prefix}/sbin' + libexecdir='${exec_prefix}/libexec' + datadir='${prefix}/share' + sysconfdir='${prefix}/etc' + sharedstatedir='${prefix}/com' + localstatedir='${prefix}/var' + libdir='${exec_prefix}/lib' + includedir='${prefix}/include' + oldincludedir='/usr/include' + infodir='${prefix}/info' + mandir='${prefix}/man' + + # Initialize some other variables. + subdirs= + MFLAGS= MAKEFLAGS= + SHELL=${CONFIG_SHELL-/bin/sh} + # Maximum number of lines to put in a shell here document. + ac_max_here_lines=12 + + ac_prev= + for ac_option + do + + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval "$ac_prev=\$ac_option" + ac_prev= + continue + fi + + case "$ac_option" in + -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) ac_optarg= ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case "$ac_option" in + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir="$ac_optarg" ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build="$ac_optarg" ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file="$ac_optarg" ;; + + -datadir | --datadir | --datadi | --datad | --data | --dat | --da) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ + | --da=*) + datadir="$ac_optarg" ;; + + -disable-* | --disable-*) + ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + eval "enable_${ac_feature}=no" ;; + + -enable-* | --enable-*) + ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "enable_${ac_feature}='$ac_optarg'" ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix="$ac_optarg" ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he) + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat << EOF + Usage: configure [options] [host] + Options: [defaults in brackets after descriptions] + Configuration: + --cache-file=FILE cache test results in FILE + --help print this message + --no-create do not create output files + --quiet, --silent do not print \`checking...' messages + --version print the version of autoconf that created configure + Directory and file names: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [same as prefix] + --bindir=DIR user executables in DIR [EPREFIX/bin] + --sbindir=DIR system admin executables in DIR [EPREFIX/sbin] + --libexecdir=DIR program executables in DIR [EPREFIX/libexec] + --datadir=DIR read-only architecture-independent data in DIR + [PREFIX/share] + --sysconfdir=DIR read-only single-machine data in DIR [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data in DIR + [PREFIX/com] + --localstatedir=DIR modifiable single-machine data in DIR [PREFIX/var] + --libdir=DIR object code libraries in DIR [EPREFIX/lib] + --includedir=DIR C header files in DIR [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc in DIR [/usr/include] + --infodir=DIR info documentation in DIR [PREFIX/info] + --mandir=DIR man documentation in DIR [PREFIX/man] + --srcdir=DIR find the sources in DIR [configure dir or ..] + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM + run sed PROGRAM on installed program names + EOF + cat << EOF + Host type: + --build=BUILD configure for building on BUILD [BUILD=HOST] + --host=HOST configure for HOST [guessed] + --target=TARGET configure for TARGET [TARGET=HOST] + Features and packages: + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR + EOF + if test -n "$ac_help"; then + echo "--enable and --with options recognized:$ac_help" + fi + exit 0 ;; + + -host | --host | --hos | --ho) + ac_prev=host ;; + -host=* | --host=* | --hos=* | --ho=*) + host="$ac_optarg" ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir="$ac_optarg" ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir="$ac_optarg" ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir="$ac_optarg" ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir="$ac_optarg" ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst \ + | --locals | --local | --loca | --loc | --lo) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* \ + | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) + localstatedir="$ac_optarg" ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir="$ac_optarg" ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir="$ac_optarg" ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix="$ac_optarg" ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix="$ac_optarg" ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix="$ac_optarg" ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name="$ac_optarg" ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir="$ac_optarg" ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir="$ac_optarg" ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site="$ac_optarg" ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir="$ac_optarg" ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir="$ac_optarg" ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target="$ac_optarg" ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers) + echo "configure generated by autoconf version 2.13" + exit 0 ;; + + -with-* | --with-*) + ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "with_${ac_package}='$ac_optarg'" ;; + + -without-* | --without-*) + ac_package=`echo $ac_option|sed -e 's/-*without-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + eval "with_${ac_package}=no" ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes="$ac_optarg" ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries="$ac_optarg" ;; + + -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; } + ;; + + *) + if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then + echo "configure: warning: $ac_option: invalid host type" 1>&2 + fi + if test "x$nonopt" != xNONE; then + { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } + fi + nonopt="$ac_option" + ;; + + esac + done + + if test -n "$ac_prev"; then + { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; } + fi + + trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + + # File descriptor usage: + # 0 standard input + # 1 file creation + # 2 errors and warnings + # 3 some systems may open it to /dev/tty + # 4 used on the Kubota Titan + # 6 checking for... messages and results + # 5 compiler messages saved in config.log + if test "$silent" = yes; then + exec 6>/dev/null + else + exec 6>&1 + fi + exec 5>./config.log + + echo "\ + This file contains any messages produced by compilers while + running configure, to aid debugging if configure makes a mistake. + " 1>&5 + + # Strip out --no-create and --no-recursion so they do not pile up. + # Also quote any args containing shell metacharacters. + ac_configure_args= + for ac_arg + do + case "$ac_arg" in + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) ;; + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;; + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) + ac_configure_args="$ac_configure_args '$ac_arg'" ;; + *) ac_configure_args="$ac_configure_args $ac_arg" ;; + esac + done + + # NLS nuisances. + # Only set these to C if already set. These must not be set unconditionally + # because not all systems understand e.g. LANG=C (notably SCO). + # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'! + # Non-C LC_CTYPE values break the ctype check. + if test "${LANG+set}" = set; then LANG=C; export LANG; fi + if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi + if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi + if test "${LC_CTYPE+set}" = set; then LC_CTYPE=C; export LC_CTYPE; fi + + # confdefs.h avoids OS command line length limits that DEFS can exceed. + rm -rf conftest* confdefs.h + # AIX cpp loses on an empty file, so make sure it contains at least a newline. + echo > confdefs.h + + # A filename unique to this package, relative to the directory that + # configure is in, which we can look for to find out if srcdir is correct. + ac_unique_file=VERSION + + # Find the source files, if location was not specified. + if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then its parent. + ac_prog=$0 + ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` + test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. + srcdir=$ac_confdir + if test ! -r $srcdir/$ac_unique_file; then + srcdir=.. + fi + else + ac_srcdir_defaulted=no + fi + if test ! -r $srcdir/$ac_unique_file; then + if test "$ac_srcdir_defaulted" = yes; then + { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; } + else + { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; } + fi + fi + srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` + + # Prefer explicitly selected file to automatically selected ones. + if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi + fi + for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then + echo "loading site script $ac_site_file" + . "$ac_site_file" + fi + done + + if test -r "$cache_file"; then + echo "loading cache $cache_file" + . $cache_file + else + echo "creating cache $cache_file" + > $cache_file + fi + + ac_ext=c + # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. + ac_cpp='$CPP $CPPFLAGS' + ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' + ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' + cross_compiling=$ac_cv_prog_cc_cross + + ac_exeext= + ac_objext=o + if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then + # Stardent Vistra SVR4 grep lacks -e, says ghazi at caip.rutgers.edu. + if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then + ac_n= ac_c=' + ' ac_t=' ' + else + ac_n=-n ac_c= ac_t= + fi + else + ac_n= ac_c='\c' ac_t= + fi + + + + + + + PACKAGE=libelf + VERSION=`cat $srcdir/VERSION` + + + # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. + if test "${enable_maintainer_mode+set}" = set; then + enableval="$enable_maintainer_mode" + mr_enable_maintainer_mode="$enableval" + else + mr_enable_maintainer_mode="${I_AM_THE_LIBELF_MAINTAINER-no}" + fi + + if test x"$mr_enable_maintainer_mode" = x"yes"; then + MAINT= + else + MAINT='maintainer-only-' + fi + + + + ALL_LINGUAS=`cd $srcdir/po && echo *.po | sed 's/\.po//g'` + + set `echo $VERSION | sed 's/\./ /g'` + MAJOR=${1-1} + MINOR=${2-0} + PATCH=${3-0} + + + echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6 + echo "configure:575: checking whether ${MAKE-make} sets \${MAKE}" >&5 + set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'` + if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftestmake <<\EOF + all: + @echo 'ac_maketemp="${MAKE}"' + EOF + # GNU make sometimes prints "make[1]: Entering...", which would confuse us. + eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=` + if test -n "$ac_maketemp"; then + eval ac_cv_prog_make_${ac_make}_set=yes + else + eval ac_cv_prog_make_${ac_make}_set=no + fi + rm -f conftestmake + fi + if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then + echo "$ac_t""yes" 1>&6 + SET_MAKE= + else + echo "$ac_t""no" 1>&6 + SET_MAKE="MAKE=${MAKE-make}" + fi + + # Extract the first word of "gcc", so it can be a program name with args. + set dummy gcc; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:604: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. + else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_CC="gcc" + break + fi + done + IFS="$ac_save_ifs" + fi + fi + CC="$ac_cv_prog_CC" + if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. + set dummy cc; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:634: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. + else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_prog_rejected=no + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + break + fi + done + IFS="$ac_save_ifs" + if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# -gt 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + set dummy "$ac_dir/$ac_word" "$@" + shift + ac_cv_prog_CC="$@" + fi + fi + fi + fi + CC="$ac_cv_prog_CC" + if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + if test -z "$CC"; then + case "`uname -s`" in + *win32* | *WIN32*) + # Extract the first word of "cl", so it can be a program name with args. + set dummy cl; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:685: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. + else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_CC="cl" + break + fi + done + IFS="$ac_save_ifs" + fi + fi + CC="$ac_cv_prog_CC" + if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + ;; + esac + fi + test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; } + fi + + echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6 + echo "configure:717: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5 + + ac_ext=c + # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. + ac_cpp='$CPP $CPPFLAGS' + ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' + ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' + cross_compiling=$ac_cv_prog_cc_cross + + cat > conftest.$ac_ext << EOF + + #line 728 "configure" + #include "confdefs.h" + + main(){return(0);} + EOF + if { (eval echo configure:733: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + ac_cv_prog_cc_works=yes + # If we can't run a trivial program, we are probably using a cross compiler. + if (./conftest; exit) 2>/dev/null; then + ac_cv_prog_cc_cross=no + else + ac_cv_prog_cc_cross=yes + fi + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + ac_cv_prog_cc_works=no + fi + rm -fr conftest* + ac_ext=c + # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. + ac_cpp='$CPP $CPPFLAGS' + ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' + ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' + cross_compiling=$ac_cv_prog_cc_cross + + echo "$ac_t""$ac_cv_prog_cc_works" 1>&6 + if test $ac_cv_prog_cc_works = no; then + { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; } + fi + echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6 + echo "configure:759: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5 + echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6 + cross_compiling=$ac_cv_prog_cc_cross + + echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 + echo "configure:764: checking whether we are using GNU C" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.c <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gcc=yes + else + ac_cv_prog_gcc=no + fi + fi + + echo "$ac_t""$ac_cv_prog_gcc" 1>&6 + + if test $ac_cv_prog_gcc = yes; then + GCC=yes + else + GCC= + fi + + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6 + echo "configure:792: checking whether ${CC-cc} accepts -g" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + echo 'void f(){}' > conftest.c + if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then + ac_cv_prog_cc_g=yes + else + ac_cv_prog_cc_g=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$ac_cv_prog_cc_g" 1>&6 + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi + else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi + fi + + echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6 + echo "configure:824: checking how to run the C preprocessor" >&5 + # On Suns, sometimes $CPP names a directory. + if test -n "$CPP" && test -d "$CPP"; then + CPP= + fi + if test -z "$CPP"; then + if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + # This must be in double quotes, not single quotes, because CPP may get + # substituted into the Makefile and "${CC-cc}" will confuse make. + CPP="${CC-cc} -E" + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. + cat > conftest.$ac_ext < + Syntax Error + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:845: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + : + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP="${CC-cc} -E -traditional-cpp" + cat > conftest.$ac_ext < + Syntax Error + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:862: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + : + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP="${CC-cc} -nologo -E" + cat > conftest.$ac_ext < + Syntax Error + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:879: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + : + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP=/lib/cpp + fi + rm -f conftest* + fi + rm -f conftest* + fi + rm -f conftest* + ac_cv_prog_CPP="$CPP" + fi + CPP="$ac_cv_prog_CPP" + else + ac_cv_prog_CPP="$CPP" + fi + echo "$ac_t""$CPP" 1>&6 + + ac_aux_dir= + for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do + if test -f $ac_dir/install-sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f $ac_dir/install.sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + fi + done + if test -z "$ac_aux_dir"; then + { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; } + fi + ac_config_guess=$ac_aux_dir/config.guess + ac_config_sub=$ac_aux_dir/config.sub + ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. + + # Find a good install program. We prefer a C program (faster), + # so one script is as good as another. But avoid the broken or + # incompatible versions: + # SysV /etc/install, /usr/sbin/install + # SunOS /usr/etc/install + # IRIX /sbin/install + # AIX /bin/install + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag + # AFS /usr/afsws/bin/install, which mishandles nonexistent args + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" + # ./install, which can be erroneously created by make from ./install.sh. + echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 + echo "configure:934: checking for a BSD compatible install" >&5 + if test -z "$INSTALL"; then + if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS=":" + for ac_dir in $PATH; do + # Account for people who put trailing slashes in PATH elements. + case "$ac_dir/" in + /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + if test -f $ac_dir/$ac_prog; then + if test $ac_prog = install && + grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + else + ac_cv_path_install="$ac_dir/$ac_prog -c" + break 2 + fi + fi + done + ;; + esac + done + IFS="$ac_save_IFS" + + fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL="$ac_cv_path_install" + else + # As a last resort, use the slow shell script. We don't cache a + # path for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the path is relative. + INSTALL="$ac_install_sh" + fi + fi + echo "$ac_t""$INSTALL" 1>&6 + + # Use test -z because SunOS4 sh mishandles braces in ${var-val}. + # It thinks the first close brace ends the variable substitution. + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}' + + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + + # Extract the first word of "ranlib", so it can be a program name with args. + set dummy ranlib; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:989: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. + else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_RANLIB="ranlib" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":" + fi + fi + RANLIB="$ac_cv_prog_RANLIB" + if test -n "$RANLIB"; then + echo "$ac_t""$RANLIB" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6 + echo "configure:1017: checking whether ln -s works" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + rm -f conftestdata + if ln -s X conftestdata 2>/dev/null + then + rm -f conftestdata + ac_cv_prog_LN_S="ln -s" + else + ac_cv_prog_LN_S=ln + fi + fi + LN_S="$ac_cv_prog_LN_S" + if test "$ac_cv_prog_LN_S" = "ln -s"; then + echo "$ac_t""yes" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + + + echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6 + echo "configure:1040: checking for ANSI C header files" >&5 + if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + #include + #include + #include + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:1053: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + rm -rf conftest* + ac_cv_header_stdc=yes + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_header_stdc=no + fi + rm -f conftest* + + if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat > conftest.$ac_ext < + EOF + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "memchr" >/dev/null 2>&1; then + : + else + rm -rf conftest* + ac_cv_header_stdc=no + fi + rm -f conftest* + + fi + + if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat > conftest.$ac_ext < + EOF + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "free" >/dev/null 2>&1; then + : + else + rm -rf conftest* + ac_cv_header_stdc=no + fi + rm -f conftest* + + fi + + if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then + : + else + cat > conftest.$ac_ext < + #define ISLOWER(c) ('a' <= (c) && (c) <= 'z') + #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) + #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) + int main () { int i; for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2); + exit (0); } + + EOF + if { (eval echo configure:1120: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + : + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_header_stdc=no + fi + rm -fr conftest* + fi + + fi + fi + + echo "$ac_t""$ac_cv_header_stdc" 1>&6 + if test $ac_cv_header_stdc = yes; then + cat >> confdefs.h <<\EOF + #define STDC_HEADERS 1 + EOF + + fi + + for ac_hdr in unistd.h fcntl.h elf.h sys/elf.h link.h sys/link.h + do + ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` + echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 + echo "configure:1147: checking for $ac_hdr" >&5 + if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:1157: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" + fi + rm -f conftest* + fi + if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'` + cat >> confdefs.h <&6 + fi + done + + if test "$ac_cv_header_elf_h" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF_HEADER_ELF_H + EOF + + elif test "$ac_cv_header_sys_elf_h" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF_HEADER_ELF_H + EOF + + fi + + for ac_hdr in ar.h libelf.h nlist.h gelf.h + do + ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` + echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 + echo "configure:1199: checking for $ac_hdr" >&5 + if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:1209: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" + fi + rm -f conftest* + fi + if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'` + cat >> confdefs.h <&6 + fi + done + + echo $ac_n "checking whether to install , and ""... $ac_c" 1>&6 + echo "configure:1236: checking whether to install , and " >&5 + # Check whether --enable-compat or --disable-compat was given. + if test "${enable_compat+set}" = set; then + enableval="$enable_compat" + DO_COMPAT="$enableval" + else + if test "$ac_cv_header_libelf_h$ac_cv_header_nlist_h$ac_cv_header_gelf_h" = yesyesyes + then DO_COMPAT=no + else DO_COMPAT=yes + fi + fi + + echo "$ac_t""$DO_COMPAT" 1>&6 + + + echo $ac_n "checking for working const""... $ac_c" 1>&6 + echo "configure:1252: checking for working const" >&5 + if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <j = 5; + } + { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ + const int foo = 10; + } + + ; return 0; } + EOF + if { (eval echo configure:1306: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_c_const=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_c_const=no + fi + rm -f conftest* + fi + + echo "$ac_t""$ac_cv_c_const" 1>&6 + if test $ac_cv_c_const = no; then + cat >> confdefs.h <<\EOF + #define const + EOF + + fi + + echo $ac_n "checking for off_t""... $ac_c" 1>&6 + echo "configure:1327: checking for off_t" >&5 + if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + #if STDC_HEADERS + #include + #include + #endif + EOF + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "(^|[^a-zA-Z_0-9])off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then + rm -rf conftest* + ac_cv_type_off_t=yes + else + rm -rf conftest* + ac_cv_type_off_t=no + fi + rm -f conftest* + + fi + echo "$ac_t""$ac_cv_type_off_t" 1>&6 + if test $ac_cv_type_off_t = no; then + cat >> confdefs.h <<\EOF + #define off_t long + EOF + + fi + + echo $ac_n "checking for size_t""... $ac_c" 1>&6 + echo "configure:1360: checking for size_t" >&5 + if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + #if STDC_HEADERS + #include + #include + #endif + EOF + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "(^|[^a-zA-Z_0-9])size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then + rm -rf conftest* + ac_cv_type_size_t=yes + else + rm -rf conftest* + ac_cv_type_size_t=no + fi + rm -f conftest* + + fi + echo "$ac_t""$ac_cv_type_size_t" 1>&6 + if test $ac_cv_type_size_t = no; then + cat >> confdefs.h <<\EOF + #define size_t unsigned + EOF + + fi + + + echo $ac_n "checking size of short""... $ac_c" 1>&6 + echo "configure:1394: checking size of short" >&5 + if eval "test \"`echo '$''{'ac_cv_sizeof_short'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + ac_cv_sizeof_short=2 + else + cat > conftest.$ac_ext < + main() + { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + fprintf(f, "%d\n", sizeof(short)); + exit(0); + } + EOF + if { (eval echo configure:1413: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + ac_cv_sizeof_short=`cat conftestval` + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_sizeof_short=0 + fi + rm -fr conftest* + fi + + fi + echo "$ac_t""$ac_cv_sizeof_short" 1>&6 + cat >> confdefs.h <&6 + echo "configure:1433: checking size of int" >&5 + if eval "test \"`echo '$''{'ac_cv_sizeof_int'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + ac_cv_sizeof_int=4 + else + cat > conftest.$ac_ext < + main() + { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + fprintf(f, "%d\n", sizeof(int)); + exit(0); + } + EOF + if { (eval echo configure:1452: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + ac_cv_sizeof_int=`cat conftestval` + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_sizeof_int=0 + fi + rm -fr conftest* + fi + + fi + echo "$ac_t""$ac_cv_sizeof_int" 1>&6 + cat >> confdefs.h <&6 + echo "configure:1472: checking size of long" >&5 + if eval "test \"`echo '$''{'ac_cv_sizeof_long'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + ac_cv_sizeof_long=4 + else + cat > conftest.$ac_ext < + main() + { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + fprintf(f, "%d\n", sizeof(long)); + exit(0); + } + EOF + if { (eval echo configure:1491: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + ac_cv_sizeof_long=`cat conftestval` + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_sizeof_long=0 + fi + rm -fr conftest* + fi + + fi + echo "$ac_t""$ac_cv_sizeof_long" 1>&6 + cat >> confdefs.h <&6 + echo "configure:1511: checking size of long long" >&5 + if eval "test \"`echo '$''{'ac_cv_sizeof_long_long'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + ac_cv_sizeof_long_long=0 + else + cat > conftest.$ac_ext < + main() + { + FILE *f=fopen("conftestval", "w"); + if (!f) exit(1); + fprintf(f, "%d\n", sizeof(long long)); + exit(0); + } + EOF + if { (eval echo configure:1530: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + ac_cv_sizeof_long_long=`cat conftestval` + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_sizeof_long_long=0 + fi + rm -fr conftest* + fi + + fi + echo "$ac_t""$ac_cv_sizeof_long_long" 1>&6 + cat >> confdefs.h <. + echo $ac_n "checking for struct Elf32_Dyn""... $ac_c" 1>&6 + echo "configure:1555: checking for struct Elf32_Dyn" >&5 + if eval "test \"`echo '$''{'libelf_cv_struct_elf32_dyn'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_elf32_dyn=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + cat > conftest.$ac_ext < + int main() { + Elf32_Dyn x + ; return 0; } + EOF + if { (eval echo configure:1583: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_elf32_dyn=link.h + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_struct_elf32_dyn=no + fi + rm -f conftest* + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_struct_elf32_dyn" 1>&6 + if test "$libelf_cv_struct_elf32_dyn" = link.h; then + cat >> confdefs.h <<\EOF + #define __LIBELF_NEED_LINK_H 1 + EOF + + elif test "$libelf_cv_struct_elf32_dyn" = no; then + { echo "configure: error: no declaration for Elf32_Dyn" 1>&2; exit 1; } + fi + + # Linux declares struct nlist in . + echo $ac_n "checking for struct nlist in elf.h""... $ac_c" 1>&6 + echo "configure:1609: checking for struct nlist in elf.h" >&5 + if eval "test \"`echo '$''{'libelf_cv_struct_nlist'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_nlist=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_struct_nlist=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_struct_nlist" 1>&6 + if test "$libelf_cv_struct_nlist" = yes; then + cat >> confdefs.h <<\EOF + #define HAVE_STRUCT_NLIST_DECLARATION 1 + EOF + + fi + + # Check for 64-bit data types. + echo $ac_n "checking for struct Elf64_Ehdr""... $ac_c" 1>&6 + echo "configure:1644: checking for struct Elf64_Ehdr" >&5 + if eval "test \"`echo '$''{'libelf_cv_struct_elf64_ehdr'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_elf64_ehdr=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_struct_elf64_ehdr=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_struct_elf64_ehdr" 1>&6 + + # Linux lacks typedefs for scalar ELF64_* types. + echo $ac_n "checking for Elf64_Addr""... $ac_c" 1>&6 + echo "configure:1672: checking for Elf64_Addr" >&5 + if eval "test \"`echo '$''{'libelf_cv_type_elf64_addr'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_type_elf64_addr=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_type_elf64_addr=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_type_elf64_addr" 1>&6 + + # IRIX' struct Elf64_Rel is slightly different. Ugh. + echo $ac_n "checking for struct Elf64_Rel""... $ac_c" 1>&6 + echo "configure:1700: checking for struct Elf64_Rel" >&5 + if eval "test \"`echo '$''{'libelf_cv_struct_elf64_rel'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_elf64_rel=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_struct_elf64_rel=irix + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_struct_elf64_rel=no + fi + rm -f conftest* + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_struct_elf64_rel" 1>&6 + + case "$libelf_cv_struct_elf64_ehdr:\ + $libelf_cv_type_elf64_addr:\ + $libelf_cv_struct_elf64_rel" in + yes:yes:yes) + libelf_64bit=yes;; + yes:yes:irix) + cat >> confdefs.h <<\EOF + #define __LIBELF64_IRIX 1 + EOF + + libelf_64bit=yes;; + yes:no:yes) + cat >> confdefs.h <<\EOF + #define __LIBELF64_LINUX 1 + EOF + + libelf_64bit=yes;; + *) + libelf_64bit=no;; + esac + + # Check for symbol versioning definitions + echo $ac_n "checking for Elf32_Verdef""... $ac_c" 1>&6 + echo "configure:1766: checking for Elf32_Verdef" >&5 + if eval "test \"`echo '$''{'libelf_cv_verdef32'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < /* Solaris wants this */ + #endif + int main() { + struct { + Elf32_Verdef vd; + Elf32_Verdaux vda; + Elf32_Verneed vn; + Elf32_Vernaux vna; + } x + ; return 0; } + EOF + if { (eval echo configure:1786: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_verdef32=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_verdef32=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_verdef32" 1>&6 + + echo $ac_n "checking for Elf64_Verdef""... $ac_c" 1>&6 + echo "configure:1801: checking for Elf64_Verdef" >&5 + if eval "test \"`echo '$''{'libelf_cv_verdef64'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < /* Solaris wants this */ + #endif + int main() { + struct { + Elf64_Verdef vd; + Elf64_Verdaux vda; + Elf64_Verneed vn; + Elf64_Vernaux vna; + } x + ; return 0; } + EOF + if { (eval echo configure:1821: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_verdef64=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_verdef64=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_verdef64" 1>&6 + + echo $ac_n "checking for SHT_SUNW_verdef""... $ac_c" 1>&6 + echo "configure:1836: checking for SHT_SUNW_verdef" >&5 + if eval "test \"`echo '$''{'libelf_cv_sun_verdef'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_sun_verdef=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_sun_verdef=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_sun_verdef" 1>&6 + + echo $ac_n "checking for SHT_GNU_verdef""... $ac_c" 1>&6 + echo "configure:1863: checking for SHT_GNU_verdef" >&5 + if eval "test \"`echo '$''{'libelf_cv_gnu_verdef'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + libelf_cv_gnu_verdef=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + libelf_cv_gnu_verdef=no + fi + rm -f conftest* + fi + + echo "$ac_t""$libelf_cv_gnu_verdef" 1>&6 + else + # lib/elf_repl.h supports 64-bit + libelf_64bit=yes + + # lib/elf_repl.h supports symbol versioning + libelf_cv_verdef32=yes + libelf_cv_verdef64=yes + libelf_cv_sun_verdef=yes + libelf_cv_gnu_verdef=yes + fi + + echo $ac_n "checking for 64-bit integer""... $ac_c" 1>&6 + echo "configure:1900: checking for 64-bit integer" >&5 + if eval "test \"`echo '$''{'libelf_cv_int64'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + if test "$ac_cv_sizeof_long" = 8; then + libelf_cv_int64='long' + elif test "$ac_cv_sizeof_long_long" = 8; then + libelf_cv_int64='long long' + else + libelf_cv_int64=no + fi + fi + + echo "$ac_t""$libelf_cv_int64" 1>&6 + if test "$libelf_cv_int64" = no; then + libelf_64bit=no + else + cat >> confdefs.h <> confdefs.h <&6 + echo "configure:1929: checking for 32-bit integer" >&5 + if eval "test \"`echo '$''{'libelf_cv_int32'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + if test "$ac_cv_sizeof_int" = 4; then + libelf_cv_int32='int' + elif test "$ac_cv_sizeof_long" = 4; then + libelf_cv_int32='long' + else + libelf_cv_int32=no + fi + fi + + echo "$ac_t""$libelf_cv_int32" 1>&6 + if test "$libelf_cv_int32" = no; then + { echo "configure: error: neither int nor long is 32-bit" 1>&2; exit 1; } + else + cat >> confdefs.h <> confdefs.h <&6 + echo "configure:1958: checking for 16-bit integer" >&5 + if eval "test \"`echo '$''{'libelf_cv_int16'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + if test "$ac_cv_sizeof_short" = 2; then + libelf_cv_int16='short' + elif test "$ac_cv_sizeof_int" = 2; then + libelf_cv_int16='int' + else + libelf_cv_int16=no + fi + fi + + echo "$ac_t""$libelf_cv_int16" 1>&6 + if test "$libelf_cv_int16" = no; then + { echo "configure: error: neither short nor int is 16-bit" 1>&2; exit 1; } + else + cat >> confdefs.h <> confdefs.h <&6 + echo "configure:1990: checking for $ac_hdr" >&5 + if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" + { (eval echo configure:2000: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" + else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" + fi + rm -f conftest* + fi + if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'` + cat >> confdefs.h <&6 + fi + done + + for ac_func in getpagesize + do + echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 + echo "configure:2029: checking for $ac_func" >&5 + if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + /* Override any gcc2 internal prototype to avoid an error. */ + /* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ + char $ac_func(); + + int main() { + + /* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ + #if defined (__stub_$ac_func) || defined (__stub___$ac_func) + choke me + #else + $ac_func(); + #endif + + ; return 0; } + EOF + if { (eval echo configure:2057: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" + fi + rm -f conftest* + fi + + if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 + fi + done + + echo $ac_n "checking for working mmap""... $ac_c" 1>&6 + echo "configure:2082: checking for working mmap" >&5 + if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + ac_cv_func_mmap_fixed_mapped=no + else + cat > conftest.$ac_ext < + #include + #include + + /* This mess was copied from the GNU getpagesize.h. */ + #ifndef HAVE_GETPAGESIZE + # ifdef HAVE_UNISTD_H + # include + # endif + + /* Assume that all systems that can run configure have sys/param.h. */ + # ifndef HAVE_SYS_PARAM_H + # define HAVE_SYS_PARAM_H 1 + # endif + + # ifdef _SC_PAGESIZE + # define getpagesize() sysconf(_SC_PAGESIZE) + # else /* no _SC_PAGESIZE */ + # ifdef HAVE_SYS_PARAM_H + # include + # ifdef EXEC_PAGESIZE + # define getpagesize() EXEC_PAGESIZE + # else /* no EXEC_PAGESIZE */ + # ifdef NBPG + # define getpagesize() NBPG * CLSIZE + # ifndef CLSIZE + # define CLSIZE 1 + # endif /* no CLSIZE */ + # else /* no NBPG */ + # ifdef NBPC + # define getpagesize() NBPC + # else /* no NBPC */ + # ifdef PAGESIZE + # define getpagesize() PAGESIZE + # endif /* PAGESIZE */ + # endif /* no NBPC */ + # endif /* no NBPG */ + # endif /* no EXEC_PAGESIZE */ + # else /* no HAVE_SYS_PARAM_H */ + # define getpagesize() 8192 /* punt totally */ + # endif /* no HAVE_SYS_PARAM_H */ + # endif /* no _SC_PAGESIZE */ + + #endif /* no HAVE_GETPAGESIZE */ + + #ifdef __cplusplus + extern "C" { void *malloc(unsigned); } + #else + char *malloc(); + #endif + + int + main() + { + char *data, *data2, *data3; + int i, pagesize; + int fd; + + pagesize = getpagesize(); + + /* + * First, make a file with some known garbage in it. + */ + data = malloc(pagesize); + if (!data) + exit(1); + for (i = 0; i < pagesize; ++i) + *(data + i) = rand(); + umask(0); + fd = creat("conftestmmap", 0600); + if (fd < 0) + exit(1); + if (write(fd, data, pagesize) != pagesize) + exit(1); + close(fd); + + /* + * Next, try to mmap the file at a fixed address which + * already has something else allocated at it. If we can, + * also make sure that we see the same garbage. + */ + fd = open("conftestmmap", O_RDWR); + if (fd < 0) + exit(1); + data2 = malloc(2 * pagesize); + if (!data2) + exit(1); + data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1); + if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_FIXED, fd, 0L)) + exit(1); + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data2 + i)) + exit(1); + + /* + * Finally, make sure that changes to the mapped area + * do not percolate back to the file as seen by read(). + * (This is a bug on some variants of i386 svr4.0.) + */ + for (i = 0; i < pagesize; ++i) + *(data2 + i) = *(data2 + i) + 1; + data3 = malloc(pagesize); + if (!data3) + exit(1); + if (read(fd, data3, pagesize) != pagesize) + exit(1); + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data3 + i)) + exit(1); + close(fd); + unlink("conftestmmap"); + exit(0); + } + + EOF + if { (eval echo configure:2230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + ac_cv_func_mmap_fixed_mapped=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_func_mmap_fixed_mapped=no + fi + rm -fr conftest* + fi + + fi + + echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6 + if test $ac_cv_func_mmap_fixed_mapped = yes; then + cat >> confdefs.h <<\EOF + #define HAVE_MMAP 1 + EOF + + fi + + for ac_func in ftruncate memcmp memcpy memmove + do + echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 + echo "configure:2255: checking for $ac_func" >&5 + if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + /* Override any gcc2 internal prototype to avoid an error. */ + /* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ + char $ac_func(); + + int main() { + + /* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ + #if defined (__stub_$ac_func) || defined (__stub___$ac_func) + choke me + #else + $ac_func(); + #endif + + ; return 0; } + EOF + if { (eval echo configure:2283: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" + fi + rm -f conftest* + fi + + if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 + fi + done + + for ac_func in memset + do + echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 + echo "configure:2310: checking for $ac_func" >&5 + if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext < + /* Override any gcc2 internal prototype to avoid an error. */ + /* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ + char $ac_func(); + + int main() { + + /* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ + #if defined (__stub_$ac_func) || defined (__stub___$ac_func) + choke me + #else + $ac_func(); + #endif + + ; return 0; } + EOF + if { (eval echo configure:2338: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" + fi + rm -f conftest* + fi + + if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 + LIBOBJS="$LIBOBJS ${ac_func}.${ac_objext}" + fi + done + + + if test "$ac_cv_func_memset" = yes; then + cat >> confdefs.h <<\EOF + #define HAVE_MEMSET 1 + EOF + + fi + + echo $ac_n "checking whether overlapping arrays are copied correctly""... $ac_c" 1>&6 + echo "configure:2372: checking whether overlapping arrays are copied correctly" >&5 + if eval "test \"`echo '$''{'libelf_cv_working_memmove'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + libelf_cv_working_memmove='maybe not' + else + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + libelf_cv_working_memmove=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + libelf_cv_working_memmove=no + fi + rm -fr conftest* + fi + + fi + + echo "$ac_t""$libelf_cv_working_memmove" 1>&6 + if test "$libelf_cv_working_memmove" != yes; then + cat >> confdefs.h <<\EOF + #define HAVE_BROKEN_MEMMOVE 1 + EOF + + fi + + echo $ac_n "checking the coffee machine""... $ac_c" 1>&6 + echo "configure:2420: checking the coffee machine" >&5 + if eval "test \"`echo '$''{'mr_cv_coffee_machine'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + mr_cv_coffee_machine='empty - operator may not work as expected' + fi + + echo "$ac_t""$mr_cv_coffee_machine" 1>&6 + + echo $ac_n "checking whether 64-bit ELF support is sufficient""... $ac_c" 1>&6 + echo "configure:2430: checking whether 64-bit ELF support is sufficient" >&5 + echo "$ac_t""$libelf_64bit" 1>&6 + echo $ac_n "checking whether to include 64-bit support""... $ac_c" 1>&6 + echo "configure:2433: checking whether to include 64-bit support" >&5 + if test "$libelf_64bit" = no; then + libelf_enable_64bit=no + else + # Check whether --enable-elf64 or --disable-elf64 was given. + if test "${enable_elf64+set}" = set; then + enableval="$enable_elf64" + libelf_enable_64bit="$enableval" + else + libelf_enable_64bit=yes + fi + + fi + echo "$ac_t""$libelf_enable_64bit" 1>&6 + if test "$libelf_enable_64bit" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF64 1 + EOF + + fi + + echo $ac_n "checking whether versioning support is sufficient""... $ac_c" 1>&6 + echo "configure:2455: checking whether versioning support is sufficient" >&5 + libelf_versioning=no + case "$libelf_enable_64bit:$libelf_cv_verdef32:$libelf_cv_verdef64" in + no:yes:* | yes:yes:yes) + if test "$libelf_cv_sun_verdef" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF_SUN_SYMBOL_VERSIONS 1 + EOF + + libelf_versioning=yes + elif test "$libelf_cv_gnu_verdef" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF_GNU_SYMBOL_VERSIONS 1 + EOF + + libelf_versioning=yes + fi;; + esac + echo "$ac_t""$libelf_versioning" 1>&6 + echo $ac_n "checking whether to include versioning support""... $ac_c" 1>&6 + echo "configure:2475: checking whether to include versioning support" >&5 + if test "$libelf_versioning" = no; then + libelf_enable_versioning=no + else + # Check whether --enable-versioning or --disable-versioning was given. + if test "${enable_versioning+set}" = set; then + enableval="$enable_versioning" + libelf_enable_versioning="$enableval" + else + libelf_enable_versioning=yes + fi + + fi + echo "$ac_t""$libelf_enable_versioning" 1>&6 + if test "$libelf_enable_versioning" = yes; then + cat >> confdefs.h <<\EOF + #define __LIBELF_SYMBOL_VERSIONS 1 + EOF + + fi + + + + + # Needed for `make dist' even if NLS is disabled. + GMOFILES= + MSGFILES= + POFILES= + for mr_lang in $ALL_LINGUAS; do + GMOFILES="$GMOFILES $mr_lang.gmo" + MSGFILES="$MSGFILES $mr_lang.msg" + POFILES="$POFILES $mr_lang.po" + done + + + + + echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6 + echo "configure:2513: checking whether NLS is requested" >&5 + # Check whether --enable-nls or --disable-nls was given. + if test "${enable_nls+set}" = set; then + enableval="$enable_nls" + mr_enable_nls="$enableval" + else + mr_enable_nls=yes + fi + + echo "$ac_t""$mr_enable_nls" 1>&6 + + CATOBJEXT= + INSTOBJEXT= + localedir= + if test "$mr_enable_nls" = yes; then + mr_PATH=`echo ":$PATH" | sed -e 's,:^:*openwin^:*,,g' -e 's,^:,,'` + echo $ac_n "checking for gettext""... $ac_c" 1>&6 + echo "configure:2530: checking for gettext" >&5 + if eval "test \"`echo '$''{'mr_cv_func_gettext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext < + int main() { + char *s = gettext(""); return 0 + ; return 0; } + EOF + if { (eval echo configure:2543: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + mr_cv_func_gettext=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + mr_cv_func_gettext=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$mr_cv_func_gettext" 1>&6 + if test "$mr_cv_func_gettext" = yes; then + # Extract the first word of "msgfmt", so it can be a program name with args. + set dummy msgfmt; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2561: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$MSGFMT" in + /*) + ac_cv_path_MSGFMT="$MSGFMT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_MSGFMT="$MSGFMT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_MSGFMT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_MSGFMT" && ac_cv_path_MSGFMT="no" + ;; + esac + fi + MSGFMT="$ac_cv_path_MSGFMT" + if test -n "$MSGFMT"; then + echo "$ac_t""$MSGFMT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + if test "$MSGFMT" != no; then + # Extract the first word of "gmsgfmt", so it can be a program name with args. + set dummy gmsgfmt; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2598: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$GMSGFMT" in + /*) + ac_cv_path_GMSGFMT="$GMSGFMT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_GMSGFMT="$GMSGFMT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_GMSGFMT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="$MSGFMT" + ;; + esac + fi + GMSGFMT="$ac_cv_path_GMSGFMT" + if test -n "$GMSGFMT"; then + echo "$ac_t""$GMSGFMT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + # Extract the first word of "xgettext", so it can be a program name with args. + set dummy xgettext; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2634: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$XGETTEXT" in + /*) + ac_cv_path_XGETTEXT="$XGETTEXT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_XGETTEXT="$XGETTEXT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_XGETTEXT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_XGETTEXT" && ac_cv_path_XGETTEXT="xgettext" + ;; + esac + fi + XGETTEXT="$ac_cv_path_XGETTEXT" + if test -n "$XGETTEXT"; then + echo "$ac_t""$XGETTEXT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + echo $ac_n "checking for GNU gettext""... $ac_c" 1>&6 + echo "configure:2668: checking for GNU gettext" >&5 + if eval "test \"`echo '$''{'mr_cv_gnu_gettext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + mr_cv_gnu_gettext=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + mr_cv_gnu_gettext=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$mr_cv_gnu_gettext" 1>&6 + if test "$mr_cv_gnu_gettext" = yes; then + echo $ac_n "checking for losing catgets-based GNU gettext""... $ac_c" 1>&6 + echo "configure:2697: checking for losing catgets-based GNU gettext" >&5 + if eval "test \"`echo '$''{'mr_cv_catgets_based_gettext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + mr_cv_catgets_based_gettext=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + mr_cv_catgets_based_gettext=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$mr_cv_catgets_based_gettext" 1>&6 + if test "$mr_cv_catgets_based_gettext" = yes; then + # This loses completely. Turn it off and use catgets. + LIBS=`echo $LIBS | sed 's,-lintl,,g'` + mr_cv_func_gettext=no + else + # Is there a better test for this case? + echo $ac_n "checking for pure GNU gettext""... $ac_c" 1>&6 + echo "configure:2731: checking for pure GNU gettext" >&5 + if eval "test \"`echo '$''{'mr_cv_pure_gnu_gettext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + mr_cv_pure_gnu_gettext=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + mr_cv_pure_gnu_gettext=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$mr_cv_pure_gnu_gettext" 1>&6 + if test "$mr_cv_pure_gnu_gettext" = yes; then + CATOBJEXT=.gmo + localedir='$(prefix)/share/locale' + else + CATOBJEXT=.mo + localedir='$(prefix)/lib/locale' + fi + INSTOBJEXT=.mo + fi + else + # System provided gettext + CATOBJEXT=.mo + INSTOBJEXT=.mo + localedir='$(prefix)/lib/locale' + fi + else + # Gettext but no msgfmt. Try catgets. + mr_cv_func_gettext=no + fi + fi + if test "$mr_cv_func_gettext" = yes; then + cat >> confdefs.h <<\EOF + #define HAVE_GETTEXT 1 + EOF + + else + echo $ac_n "checking for catgets""... $ac_c" 1>&6 + echo "configure:2785: checking for catgets" >&5 + if eval "test \"`echo '$''{'mr_cv_func_catgets'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + + cat > conftest.$ac_ext < + int main() { + catgets(catopen("",0),0,0,"");return 0; + ; return 0; } + EOF + if { (eval echo configure:2798: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + mr_cv_func_catgets=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + mr_cv_func_catgets=no + fi + rm -f conftest* + + fi + + echo "$ac_t""$mr_cv_func_catgets" 1>&6 + if test "$mr_cv_func_catgets" = yes; then + # Extract the first word of "gencat", so it can be a program name with args. + set dummy gencat; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2816: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_GENCAT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$GENCAT" in + /*) + ac_cv_path_GENCAT="$GENCAT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_GENCAT="$GENCAT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_GENCAT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_GENCAT" && ac_cv_path_GENCAT="no" + ;; + esac + fi + GENCAT="$ac_cv_path_GENCAT" + if test -n "$GENCAT"; then + echo "$ac_t""$GENCAT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + if test "$GENCAT" != no; then + cat >> confdefs.h <<\EOF + #define HAVE_CATGETS 1 + EOF + + # Extract the first word of "gmsgfmt msgfmt", so it can be a program name with args. + set dummy gmsgfmt msgfmt; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2857: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$GMSGFMT" in + /*) + ac_cv_path_GMSGFMT="$GMSGFMT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_GMSGFMT="$GMSGFMT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_GMSGFMT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_GMSGFMT" && ac_cv_path_GMSGFMT="msgfmt" + ;; + esac + fi + GMSGFMT="$ac_cv_path_GMSGFMT" + if test -n "$GMSGFMT"; then + echo "$ac_t""$GMSGFMT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + # Extract the first word of "xgettext", so it can be a program name with args. + set dummy xgettext; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:2893: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$XGETTEXT" in + /*) + ac_cv_path_XGETTEXT="$XGETTEXT" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_XGETTEXT="$XGETTEXT" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$mr_PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_XGETTEXT="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_XGETTEXT" && ac_cv_path_XGETTEXT="xgettext" + ;; + esac + fi + XGETTEXT="$ac_cv_path_XGETTEXT" + if test -n "$XGETTEXT"; then + echo "$ac_t""$XGETTEXT" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + CATOBJEXT=.cat + INSTOBJEXT=.cat + localedir='$(prefix)/lib/locale' + fi + else + echo "configure: warning: no NLS support, disabled" 1>&2 + mr_enable_nls=no + fi + fi + fi + + + + + POSUB= + CATALOGS= + if test "$mr_enable_nls" = yes; then + echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6 + echo "configure:2944: checking for catalogs to be installed" >&5 + mr_linguas= + for mr_lang in ${LINGUAS=$ALL_LINGUAS}; do + case " $ALL_LINGUAS " in + *" $mr_lang "*) + mr_linguas="$mr_linguas$mr_lang " + CATALOGS="$CATALOGS $mr_lang$CATOBJEXT" + ;; + esac + done + echo "$ac_t""$mr_linguas" 1>&6 + POSUB=po + fi + + + + + + # Make sure we can run config.sub. + if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then : + else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; } + fi + + echo $ac_n "checking host system type""... $ac_c" 1>&6 + echo "configure:2968: checking host system type" >&5 + + host_alias=$host + case "$host_alias" in + NONE) + case $nonopt in + NONE) + if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then : + else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; } + fi ;; + *) host_alias=$nonopt ;; + esac ;; + esac + + host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias` + host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` + host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` + host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` + echo "$ac_t""$host" 1>&6 + + + + PICFLAGS= + SHLIB_SFX= + SHLINK_SFX= + SONAME_SFX= + LINK_SHLIB= + INSTALL_SHLIB= + DEPSHLIBS= + echo $ac_n "checking whether to build a shared library""... $ac_c" 1>&6 + echo "configure:2998: checking whether to build a shared library" >&5 + # Check whether --enable-shared or --disable-shared was given. + if test "${enable_shared+set}" = set; then + enableval="$enable_shared" + mr_enable_shared="$enableval" + else + mr_enable_shared=yes + fi + + echo "$ac_t""$mr_enable_shared" 1>&6 + if test "$mr_enable_shared" = yes; then + echo $ac_n "checking whether GNU naming conventions are requested""... $ac_c" 1>&6 + echo "configure:3010: checking whether GNU naming conventions are requested" >&5 + # Check whether --enable-gnu_names or --disable-gnu_names was given. + if test "${enable_gnu_names+set}" = set; then + enableval="$enable_gnu_names" + mr_enable_gnu_names="$enableval" + else + mr_enable_gnu_names=no + fi + + echo "$ac_t""$mr_enable_gnu_names" 1>&6 + + + # Extract the first word of "ld", so it can be a program name with args. + set dummy ld; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 + echo "configure:3025: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + case "$LD" in + /*) + ac_cv_path_LD="$LD" # Let the user override the test with a path. + ;; + ?:/*) + ac_cv_path_LD="$LD" # Let the user override the test with a dos path. + ;; + *) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_path_LD="$ac_dir/$ac_word" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_LD" && ac_cv_path_LD="ld" + ;; + esac + fi + LD="$ac_cv_path_LD" + if test -n "$LD"; then + echo "$ac_t""$LD" 1>&6 + else + echo "$ac_t""no" 1>&6 + fi + + case "$host" in + *-linux*|*-gnu*) + if test "$GCC" = yes; then + + + echo $ac_n "checking for native ELF system""... $ac_c" 1>&6 + echo "configure:3064: checking for native ELF system" >&5 + if eval "test \"`echo '$''{'mr_cv_target_elf'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + if test "$cross_compiling" = yes; then + mr_cv_target_elf=no + else + cat > conftest.$ac_ext < + int + main(int argc, char **argv) { + char buf[BUFSIZ]; + FILE *fp; + int n; + + if ((fp = fopen(*argv, "r")) == NULL) { + exit(1); + } + n = fread(buf, 1, sizeof(buf), fp); + if (n >= 52 + && buf[0] == '\177' + && buf[1] == 'E' + && buf[2] == 'L' + && buf[3] == 'F') { + exit(0); + } + exit(1); + } + EOF + if { (eval echo configure:3095: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null + then + mr_cv_target_elf=yes + else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + mr_cv_target_elf=no + fi + rm -fr conftest* + fi + + fi + + echo "$ac_t""$mr_cv_target_elf" 1>&6 + if test "$mr_cv_target_elf" = yes; then + PICFLAGS='-fPIC -DPIC' + if test "$mr_enable_gnu_names" = yes + then + SHLIB_SFX='-$(VERSION).so' + else + SHLIB_SFX='.so.$(VERSION)' + fi + SHLINK_SFX='.so' + SONAME_SFX='.so.$(MAJOR)' + LINK_SHLIB='$(CC) -shared -Wl,-soname,$(SONAME)' + INSTALL_SHLIB='$(INSTALL_PROGRAM)' + DEPSHLIBS='-lc' + else + echo "configure: warning: shared libraries not supported for $host" 1>&2 + mr_enable_shared=no + fi + else + echo "configure: warning: GNU CC required for building shared libraries" 1>&2 + mr_enable_shared=no + fi + ;; + sparc-sun-solaris2*) + if test "$GCC" = yes; then + PICFLAGS='-fPIC -DPIC' + else + PICFLAGS='-K PIC -DPIC' + fi + if test "$mr_enable_gnu_names" = yes + then + SHLIB_SFX='-$(MAJOR).so' + else + SHLIB_SFX='.so.$(MAJOR)' + fi + SONAME_SFX='.so.$(MAJOR)' + SHLINK_SFX='.so' + LINK_SHLIB='$(LD) -G -z text -h $(SONAME)' + INSTALL_SHLIB='$(INSTALL_PROGRAM)' + ;; + *) + echo "configure: warning: shared libraries not supported for $host" 1>&2 + mr_enable_shared=no + ;; + esac + else + mr_enable_shared=no + fi + + + + + + + + DO_SHLIB="$mr_enable_shared" + + + + + + # Check whether --enable-debug or --disable-debug was given. + if test "${enable_debug+set}" = set; then + enableval="$enable_debug" + mr_enable_debug="$enableval" + else + mr_enable_debug=no + fi + + if test "$mr_enable_debug" = yes; then + cat >> confdefs.h <<\EOF + #define ENABLE_DEBUG 1 + EOF + + fi + + + trap '' 1 2 15 + cat > confcache <<\EOF + # This file is a shell script that caches the results of configure + # tests run on this system so they can be shared between configure + # scripts and configure runs. It is not useful on other systems. + # If it contains results you don't want to keep, you may remove or edit it. + # + # By default, configure uses ./config.cache as the cache file, + # creating it if it does not exist already. You can give configure + # the --cache-file=FILE option to use a different cache file; that is + # what configure does when it calls configure scripts in + # subdirectories, so they share the cache. + # Giving --cache-file=/dev/null disables caching, for debugging configure. + # config.status only pays attention to the cache file if you give it the + # --recheck option to rerun configure. + # + EOF + # The following way of writing the cache mishandles newlines in values, + # but we know of no workaround that is simple, portable, and efficient. + # So, don't put newlines in cache variables' values. + # Ultrix sh set writes to stderr and can't be redirected directly, + # and sets the high bit in the cache file unless we assign to the vars. + (set) 2>&1 | + case `(ac_space=' '; set | grep ac_space) 2>&1` in + *ac_space=\ *) + # `set' does not quote correctly, so add quotes (double-quote substitution + # turns \\\\ into \\, and sed turns \\ into \). + sed -n \ + -e "s/'/'\\\\''/g" \ + -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p" + ;; + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p' + ;; + esac >> confcache + if cmp -s $cache_file confcache; then + : + else + if test -w $cache_file; then + echo "updating cache $cache_file" + cat confcache > $cache_file + else + echo "not updating unwritable cache $cache_file" + fi + fi + rm -f confcache + + trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + + test "x$prefix" = xNONE && prefix=$ac_default_prefix + # Let make expand exec_prefix. + test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + + # Any assignment to VPATH causes Sun make to only execute + # the first set of double-colon rules, so remove it if not needed. + # If there is a colon in the path, we need to keep it. + if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' + fi + + trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15 + + DEFS=-DHAVE_CONFIG_H + + # Without the "./", some shells look in PATH for config.status. + : ${CONFIG_STATUS=./config.status} + + echo creating $CONFIG_STATUS + rm -f $CONFIG_STATUS + cat > $CONFIG_STATUS </dev/null | sed 1q`: + # + # $0 $ac_configure_args + # + # Compiler output produced by configure, useful for debugging + # configure, is in ./config.log if it exists. + + ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]" + for ac_option + do + case "\$ac_option" in + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion" + exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;; + -version | --version | --versio | --versi | --vers | --ver | --ve | --v) + echo "$CONFIG_STATUS generated by autoconf version 2.13" + exit 0 ;; + -help | --help | --hel | --he | --h) + echo "\$ac_cs_usage"; exit 0 ;; + *) echo "\$ac_cs_usage"; exit 1 ;; + esac + done + + ac_given_srcdir=$srcdir + ac_given_INSTALL="$INSTALL" + + trap 'rm -fr `echo "Makefile lib/Makefile po/Makefile config.h lib/sys_elf.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 + EOF + cat >> $CONFIG_STATUS < conftest.subs <<\\CEOF + $ac_vpsub + $extrasub + s%@SHELL@%$SHELL%g + s%@CFLAGS@%$CFLAGS%g + s%@CPPFLAGS@%$CPPFLAGS%g + s%@CXXFLAGS@%$CXXFLAGS%g + s%@FFLAGS@%$FFLAGS%g + s%@DEFS@%$DEFS%g + s%@LDFLAGS@%$LDFLAGS%g + s%@LIBS@%$LIBS%g + s%@exec_prefix@%$exec_prefix%g + s%@prefix@%$prefix%g + s%@program_transform_name@%$program_transform_name%g + s%@bindir@%$bindir%g + s%@sbindir@%$sbindir%g + s%@libexecdir@%$libexecdir%g + s%@datadir@%$datadir%g + s%@sysconfdir@%$sysconfdir%g + s%@sharedstatedir@%$sharedstatedir%g + s%@localstatedir@%$localstatedir%g + s%@libdir@%$libdir%g + s%@includedir@%$includedir%g + s%@oldincludedir@%$oldincludedir%g + s%@infodir@%$infodir%g + s%@mandir@%$mandir%g + s%@PACKAGE@%$PACKAGE%g + s%@VERSION@%$VERSION%g + s%@MAINT@%$MAINT%g + s%@MAJOR@%$MAJOR%g + s%@SET_MAKE@%$SET_MAKE%g + s%@CC@%$CC%g + s%@CPP@%$CPP%g + s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g + s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g + s%@INSTALL_DATA@%$INSTALL_DATA%g + s%@RANLIB@%$RANLIB%g + s%@LN_S@%$LN_S%g + s%@DO_COMPAT@%$DO_COMPAT%g + s%@LIBOBJS@%$LIBOBJS%g + s%@GMOFILES@%$GMOFILES%g + s%@MSGFILES@%$MSGFILES%g + s%@POFILES@%$POFILES%g + s%@MSGFMT@%$MSGFMT%g + s%@GMSGFMT@%$GMSGFMT%g + s%@XGETTEXT@%$XGETTEXT%g + s%@GENCAT@%$GENCAT%g + s%@CATOBJEXT@%$CATOBJEXT%g + s%@INSTOBJEXT@%$INSTOBJEXT%g + s%@localedir@%$localedir%g + s%@CATALOGS@%$CATALOGS%g + s%@POSUB@%$POSUB%g + s%@host@%$host%g + s%@host_alias@%$host_alias%g + s%@host_cpu@%$host_cpu%g + s%@host_vendor@%$host_vendor%g + s%@host_os@%$host_os%g + s%@LD@%$LD%g + s%@PICFLAGS@%$PICFLAGS%g + s%@SHLIB_SFX@%$SHLIB_SFX%g + s%@SHLINK_SFX@%$SHLINK_SFX%g + s%@SONAME_SFX@%$SONAME_SFX%g + s%@LINK_SHLIB@%$LINK_SHLIB%g + s%@INSTALL_SHLIB@%$INSTALL_SHLIB%g + s%@DEPSHLIBS@%$DEPSHLIBS%g + s%@DO_SHLIB@%$DO_SHLIB%g + + CEOF + EOF + + cat >> $CONFIG_STATUS <<\EOF + + # Split the substitutions into bite-sized pieces for seds with + # small command number limits, like on Digital OSF/1 and HP-UX. + ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script. + ac_file=1 # Number of current file. + ac_beg=1 # First line for current file. + ac_end=$ac_max_sed_cmds # Line after last line for current file. + ac_more_lines=: + ac_sed_cmds="" + while $ac_more_lines; do + if test $ac_beg -gt 1; then + sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file + else + sed "${ac_end}q" conftest.subs > conftest.s$ac_file + fi + if test ! -s conftest.s$ac_file; then + ac_more_lines=false + rm -f conftest.s$ac_file + else + if test -z "$ac_sed_cmds"; then + ac_sed_cmds="sed -f conftest.s$ac_file" + else + ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file" + fi + ac_file=`expr $ac_file + 1` + ac_beg=$ac_end + ac_end=`expr $ac_end + $ac_max_sed_cmds` + fi + done + if test -z "$ac_sed_cmds"; then + ac_sed_cmds=cat + fi + EOF + + cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF + for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories. + + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`" + # A "../" for each directory in $ac_dir_suffix. + ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` + else + ac_dir_suffix= ac_dots= + fi + + case "$ac_given_srcdir" in + .) srcdir=. + if test -z "$ac_dots"; then top_srcdir=. + else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; + /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; + *) # Relative path. + srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" + top_srcdir="$ac_dots$ac_given_srcdir" ;; + esac + + case "$ac_given_INSTALL" in + [/$]*) INSTALL="$ac_given_INSTALL" ;; + *) INSTALL="$ac_dots$ac_given_INSTALL" ;; + esac + + echo creating "$ac_file" + rm -f "$ac_file" + configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." + case "$ac_file" in + *Makefile*) ac_comsub="1i\\ + # $configure_input" ;; + *) ac_comsub= ;; + esac + + ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` + sed -e "$ac_comsub + s%@configure_input@%$configure_input%g + s%@srcdir@%$srcdir%g + s%@top_srcdir@%$top_srcdir%g + s%@INSTALL@%$INSTALL%g + " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file + fi; done + rm -f conftest.s* + + # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where + # NAME is the cpp macro being defined and VALUE is the value it is being given. + # + # ac_d sets the value in "#define NAME VALUE" lines. + ac_dA='s%^\([ ]*\)#\([ ]*define[ ][ ]*\)' + ac_dB='\([ ][ ]*\)[^ ]*%\1#\2' + ac_dC='\3' + ac_dD='%g' + # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". + ac_uA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' + ac_uB='\([ ]\)%\1#\2define\3' + ac_uC=' ' + ac_uD='\4%g' + # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". + ac_eA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' + ac_eB='$%\1#\2define\3' + ac_eC=' ' + ac_eD='%g' + + if test "${CONFIG_HEADERS+set}" != set; then + EOF + cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF + fi + for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + echo creating $ac_file + + rm -f conftest.frag conftest.in conftest.out + ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` + cat $ac_file_inputs > conftest.in + + EOF + + # Transform confdefs.h into a sed script conftest.vals that substitutes + # the proper values into config.h.in to produce config.h. And first: + # Protect against being on the right side of a sed subst in config.status. + # Protect against being in an unquoted here document in config.status. + rm -f conftest.vals + cat > conftest.hdr <<\EOF + s/[\\&%]/\\&/g + s%[\\$`]%\\&%g + s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp + s%ac_d%ac_u%gp + s%ac_u%ac_e%gp + EOF + sed -n -f conftest.hdr confdefs.h > conftest.vals + rm -f conftest.hdr + + # This sed command replaces #undef with comments. This is necessary, for + # example, in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + cat >> conftest.vals <<\EOF + s%^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */% + EOF + + # Break up conftest.vals because some shells have a limit on + # the size of here documents, and old seds have small limits too. + + rm -f conftest.tail + while : + do + ac_lines=`grep -c . conftest.vals` + # grep -c gives empty output for an empty file on some AIX systems. + if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi + # Write a limited-size here document to conftest.frag. + echo ' cat > conftest.frag <> $CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS + echo 'CEOF + sed -f conftest.frag conftest.in > conftest.out + rm -f conftest.in + mv conftest.out conftest.in + ' >> $CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail + rm -f conftest.vals + mv conftest.tail conftest.vals + done + rm -f conftest.vals + + cat >> $CONFIG_STATUS <<\EOF + rm -f conftest.frag conftest.h + echo "/* $ac_file. Generated automatically by configure. */" > conftest.h + cat conftest.in >> conftest.h + rm -f conftest.in + if cmp -s $ac_file conftest.h 2>/dev/null; then + echo "$ac_file is unchanged" + rm -f conftest.h + else + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + fi + rm -f $ac_file + mv conftest.h $ac_file + fi + fi; done + + EOF + cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF + echo timestamp > stamp-h + echo timestamp > lib/stamp-h + exit 0 + EOF + chmod +x $CONFIG_STATUS + rm -fr confdefs* $ac_clean_files + test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1 + + + # vi: set ts=8 sw=2 : Index: llvm/lib/CodeGen/ELF/configure.in diff -c /dev/null llvm/lib/CodeGen/ELF/configure.in:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/configure.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,318 ---- + # configure.in - Configure template for libelf. + # Copyright (C) 1995 - 2003 Michael Riepe + # Process this file with autoconf to produce a configure script. + + # @(#) $Id: configure.in,v 1.1 2005/06/22 06:35:57 reid Exp $ + + AC_INIT(VERSION) + AC_CONFIG_HEADER(config.h lib/sys_elf.h) + + AC_PREREQ(2.13) + + mr_PACKAGE(libelf) + + dnl NOTE: there must be at least one .po file! + ALL_LINGUAS=`cd $srcdir/po && echo *.po | sed 's/\.po//g'` + + dnl Assuming all arguments have already been processed... + set `echo $VERSION | sed 's/\./ /g'` + MAJOR=${1-1} + MINOR=${2-0} + PATCH=${3-0} + AC_SUBST(MAJOR) + + dnl Checks for programs. + AC_PROG_MAKE_SET + AC_PROG_CC + AC_PROG_CPP + AC_PROG_INSTALL + AC_PROG_RANLIB + AC_PROG_LN_S + + dnl Checks for libraries. + + dnl Checks for header files. + AC_HEADER_STDC + AC_CHECK_HEADERS(unistd.h fcntl.h elf.h sys/elf.h link.h sys/link.h) + if test "$ac_cv_header_elf_h" = yes; then + AC_DEFINE(__LIBELF_HEADER_ELF_H, []) + elif test "$ac_cv_header_sys_elf_h" = yes; then + AC_DEFINE(__LIBELF_HEADER_ELF_H, []) + fi + + AC_CHECK_HEADERS(ar.h libelf.h nlist.h gelf.h) + AC_MSG_CHECKING([whether to install , and ]) + AC_ARG_ENABLE(compat, + [ --enable-compat install , and (default: auto)], + [DO_COMPAT="$enableval"], + [if test "$ac_cv_header_libelf_h$ac_cv_header_nlist_h$ac_cv_header_gelf_h" = yesyesyes + then DO_COMPAT=no + else DO_COMPAT=yes + fi]) + AC_MSG_RESULT($DO_COMPAT) + AC_SUBST(DO_COMPAT) + + dnl Checks for typedefs, structures, and compiler characteristics. + AC_C_CONST + AC_TYPE_OFF_T + AC_TYPE_SIZE_T + + AC_CHECK_SIZEOF(short,2) + AC_CHECK_SIZEOF(int,4) + AC_CHECK_SIZEOF(long,4) + AC_CHECK_SIZEOF(long long,0) + + if test "$ac_cv_header_elf_h" = yes \ + || test "$ac_cv_header_sys_elf_h" = yes; then + + # Slowaris declares Elf32_Dyn in . + AC_CACHE_CHECK([for struct Elf32_Dyn], libelf_cv_struct_elf32_dyn, [ + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], [Elf32_Dyn x], + [libelf_cv_struct_elf32_dyn=yes], + AC_TRY_COMPILE([#include ], [Elf32_Dyn x], + [libelf_cv_struct_elf32_dyn=link.h], + [libelf_cv_struct_elf32_dyn=no]))]) + if test "$libelf_cv_struct_elf32_dyn" = link.h; then + AC_DEFINE(__LIBELF_NEED_LINK_H) + elif test "$libelf_cv_struct_elf32_dyn" = no; then + AC_MSG_ERROR([no declaration for Elf32_Dyn]) + fi + + # Linux declares struct nlist in . + AC_CACHE_CHECK([for struct nlist in elf.h], libelf_cv_struct_nlist, [ + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], [struct nlist nl], + [libelf_cv_struct_nlist=yes], + [libelf_cv_struct_nlist=no])]) + if test "$libelf_cv_struct_nlist" = yes; then + AC_DEFINE(HAVE_STRUCT_NLIST_DECLARATION) + fi + + # Check for 64-bit data types. + AC_CACHE_CHECK([for struct Elf64_Ehdr], libelf_cv_struct_elf64_ehdr, + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf64_Ehdr x], + [libelf_cv_struct_elf64_ehdr=yes], + [libelf_cv_struct_elf64_ehdr=no])) + + # Linux lacks typedefs for scalar ELF64_* types. + AC_CACHE_CHECK([for Elf64_Addr], libelf_cv_type_elf64_addr, + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf64_Addr x], + [libelf_cv_type_elf64_addr=yes], + [libelf_cv_type_elf64_addr=no])) + + # IRIX' struct Elf64_Rel is slightly different. Ugh. + AC_CACHE_CHECK([for struct Elf64_Rel], libelf_cv_struct_elf64_rel, + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf64_Rel x; x.r_info = 1], + [libelf_cv_struct_elf64_rel=yes], + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf64_Rel x; x.r_sym = 1], + [libelf_cv_struct_elf64_rel=irix], + [libelf_cv_struct_elf64_rel=no]))) + + case "$libelf_cv_struct_elf64_ehdr:\ + $libelf_cv_type_elf64_addr:\ + $libelf_cv_struct_elf64_rel" in + yes:yes:yes) + libelf_64bit=yes;; + yes:yes:irix) + AC_DEFINE(__LIBELF64_IRIX) + libelf_64bit=yes;; + yes:no:yes) + AC_DEFINE(__LIBELF64_LINUX) + libelf_64bit=yes;; + *) + libelf_64bit=no;; + esac + + # Check for symbol versioning definitions + AC_CACHE_CHECK([for Elf32_Verdef], libelf_cv_verdef32, + AC_TRY_COMPILE( + [#include __LIBELF_HEADER_ELF_H + #if __LIBELF_NEED_LINK_H + #include /* Solaris wants this */ + #endif], + [struct { + Elf32_Verdef vd; + Elf32_Verdaux vda; + Elf32_Verneed vn; + Elf32_Vernaux vna; + } x], + [libelf_cv_verdef32=yes], + [libelf_cv_verdef32=no])) + + AC_CACHE_CHECK([for Elf64_Verdef], libelf_cv_verdef64, + AC_TRY_COMPILE( + [#include __LIBELF_HEADER_ELF_H + #if __LIBELF_NEED_LINK_H + #include /* Solaris wants this */ + #endif], + [struct { + Elf64_Verdef vd; + Elf64_Verdaux vda; + Elf64_Verneed vn; + Elf64_Vernaux vna; + } x], + [libelf_cv_verdef64=yes], + [libelf_cv_verdef64=no])) + + AC_CACHE_CHECK([for SHT_SUNW_verdef], libelf_cv_sun_verdef, + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf32_Word x = SHT_SUNW_verdef + SHT_SUNW_verneed + SHT_SUNW_versym], + [libelf_cv_sun_verdef=yes], + [libelf_cv_sun_verdef=no])) + + AC_CACHE_CHECK([for SHT_GNU_verdef], libelf_cv_gnu_verdef, + AC_TRY_COMPILE([#include __LIBELF_HEADER_ELF_H], + [Elf32_Word x = SHT_GNU_verdef + SHT_GNU_verneed + SHT_GNU_versym], + [libelf_cv_gnu_verdef=yes], + [libelf_cv_gnu_verdef=no])) + else + # lib/elf_repl.h supports 64-bit + libelf_64bit=yes + + # lib/elf_repl.h supports symbol versioning + libelf_cv_verdef32=yes + libelf_cv_verdef64=yes + libelf_cv_sun_verdef=yes + libelf_cv_gnu_verdef=yes + fi + + AC_CACHE_CHECK([for 64-bit integer], libelf_cv_int64, [ + if test "$ac_cv_sizeof_long" = 8; then + libelf_cv_int64='long' + elif test "$ac_cv_sizeof_long_long" = 8; then + libelf_cv_int64='long long' + else + libelf_cv_int64=no + fi]) + if test "$libelf_cv_int64" = no; then + libelf_64bit=no + else + AC_DEFINE_UNQUOTED(__libelf_i64_t, [$libelf_cv_int64]) + AC_DEFINE_UNQUOTED(__libelf_u64_t, [unsigned $libelf_cv_int64]) + fi + + AC_CACHE_CHECK([for 32-bit integer], libelf_cv_int32, [ + if test "$ac_cv_sizeof_int" = 4; then + libelf_cv_int32='int' + elif test "$ac_cv_sizeof_long" = 4; then + libelf_cv_int32='long' + else + libelf_cv_int32=no + fi]) + if test "$libelf_cv_int32" = no; then + AC_MSG_ERROR([neither int nor long is 32-bit]) + else + AC_DEFINE_UNQUOTED(__libelf_i32_t, [$libelf_cv_int32]) + AC_DEFINE_UNQUOTED(__libelf_u32_t, [unsigned $libelf_cv_int32]) + fi + + AC_CACHE_CHECK([for 16-bit integer], libelf_cv_int16, [ + if test "$ac_cv_sizeof_short" = 2; then + libelf_cv_int16='short' + elif test "$ac_cv_sizeof_int" = 2; then + libelf_cv_int16='int' + else + libelf_cv_int16=no + fi]) + if test "$libelf_cv_int16" = no; then + AC_MSG_ERROR([neither short nor int is 16-bit]) + else + AC_DEFINE_UNQUOTED(__libelf_i16_t, [$libelf_cv_int16]) + AC_DEFINE_UNQUOTED(__libelf_u16_t, [unsigned $libelf_cv_int16]) + fi + + dnl Checks for library functions. + AC_FUNC_MMAP + AC_CHECK_FUNCS(ftruncate memcmp memcpy memmove) + AC_REPLACE_FUNCS(memset) + if test "$ac_cv_func_memset" = yes; then + AC_DEFINE(HAVE_MEMSET) + fi + + AC_CACHE_CHECK([whether overlapping arrays are copied correctly], + libelf_cv_working_memmove, + [AC_TRY_RUN(changequote(<<, >>)dnl + <<#include "confdefs.h" + #if HAVE_MEMMOVE + extern void *memmove(); + #else + extern void bcopy(); + #define memmove(d,s,n) bcopy((s),(d),(n)) + #endif + extern int strcmp(); + main() { + char buf[] = "0123456789"; + memmove(buf + 1, buf, 9); + if (strcmp(buf, "0012345678")) exit(1); + exit(0); + }>>, changequote([, ])dnl + libelf_cv_working_memmove=yes, + libelf_cv_working_memmove=no, + libelf_cv_working_memmove='maybe not')]) + if test "$libelf_cv_working_memmove" != yes; then + AC_DEFINE(HAVE_BROKEN_MEMMOVE) + fi + + AC_CACHE_CHECK([the coffee machine], mr_cv_coffee_machine, + [mr_cv_coffee_machine='empty - operator may not work as expected']) + + dnl Check for 64-bit support. + AC_MSG_CHECKING([whether 64-bit ELF support is sufficient]) + AC_MSG_RESULT($libelf_64bit) + AC_MSG_CHECKING([whether to include 64-bit support]) + if test "$libelf_64bit" = no; then + libelf_enable_64bit=no + else + AC_ARG_ENABLE(elf64, + [ --enable-elf64 compile in 64-bit support (default: auto)], + [libelf_enable_64bit="$enableval"], + [libelf_enable_64bit=yes]) + fi + AC_MSG_RESULT($libelf_enable_64bit) + if test "$libelf_enable_64bit" = yes; then + AC_DEFINE(__LIBELF64) + fi + + AC_MSG_CHECKING([whether versioning support is sufficient]) + libelf_versioning=no + case "$libelf_enable_64bit:$libelf_cv_verdef32:$libelf_cv_verdef64" in + no:yes:* | yes:yes:yes) + if test "$libelf_cv_sun_verdef" = yes; then + AC_DEFINE(__LIBELF_SUN_SYMBOL_VERSIONS) + libelf_versioning=yes + elif test "$libelf_cv_gnu_verdef" = yes; then + AC_DEFINE(__LIBELF_GNU_SYMBOL_VERSIONS) + libelf_versioning=yes + fi;; + esac + AC_MSG_RESULT($libelf_versioning) + AC_MSG_CHECKING([whether to include versioning support]) + if test "$libelf_versioning" = no; then + libelf_enable_versioning=no + else + AC_ARG_ENABLE(versioning, + [ --enable-versioning compile in versioning support (default: auto)], + [libelf_enable_versioning="$enableval"], + [libelf_enable_versioning=yes]) + fi + AC_MSG_RESULT($libelf_enable_versioning) + if test "$libelf_enable_versioning" = yes; then + AC_DEFINE(__LIBELF_SYMBOL_VERSIONS) + fi + + dnl Check for NLS support. + mr_ENABLE_NLS + + dnl Check for shared library support. + mr_ENABLE_SHARED + + dnl Check for debug support. + mr_ENABLE_DEBUG + + AC_OUTPUT([Makefile lib/Makefile po/Makefile], [echo timestamp > stamp-h + echo timestamp > lib/stamp-h]) + + # vi: set ts=8 sw=2 : Index: llvm/lib/CodeGen/ELF/install-sh diff -c /dev/null llvm/lib/CodeGen/ELF/install-sh:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/install-sh Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,119 ---- + #!/bin/sh + + # + # install - install a program, script, or datafile + # This comes from X11R5; it is not part of GNU. + # + # $XConsortium: install.sh,v 1.2 89/12/18 14:47:22 jim Exp $ + # + # This script is compatible with the BSD install script, but was written + # from scratch. + # + + + # set DOITPROG to echo to test this script + + # Don't use :- since 4.3BSD and earlier shells don't like it. + doit="${DOITPROG-}" + + + # put in absolute paths if you don't have them in your path; or use env. vars. + + mvprog="${MVPROG-mv}" + cpprog="${CPPROG-cp}" + chmodprog="${CHMODPROG-chmod}" + chownprog="${CHOWNPROG-chown}" + chgrpprog="${CHGRPPROG-chgrp}" + stripprog="${STRIPPROG-strip}" + rmprog="${RMPROG-rm}" + + instcmd="$mvprog" + chmodcmd="" + chowncmd="" + chgrpcmd="" + stripcmd="" + rmcmd="$rmprog -f" + mvcmd="$mvprog" + src="" + dst="" + + while [ x"$1" != x ]; do + case $1 in + -c) instcmd="$cpprog" + shift + continue;; + + -m) chmodcmd="$chmodprog $2" + shift + shift + continue;; + + -o) chowncmd="$chownprog $2" + shift + shift + continue;; + + -g) chgrpcmd="$chgrpprog $2" + shift + shift + continue;; + + -s) stripcmd="$stripprog" + shift + continue;; + + *) if [ x"$src" = x ] + then + src=$1 + else + dst=$1 + fi + shift + continue;; + esac + done + + if [ x"$src" = x ] + then + echo "install: no input file specified" + exit 1 + fi + + if [ x"$dst" = x ] + then + echo "install: no destination specified" + exit 1 + fi + + + # If destination is a directory, append the input filename; if your system + # does not like double slashes in filenames, you may need to add some logic + + if [ -d $dst ] + then + dst="$dst"/`basename $src` + fi + + # Make a temp file name in the proper directory. + + dstdir=`dirname $dst` + dsttmp=$dstdir/#inst.$$# + + # Move or copy the file name to the temp name + + $doit $instcmd $src $dsttmp + + # and set any options; do chmod last to preserve setuid bits + + if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; fi + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; fi + if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; fi + if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; fi + + # Now rename the file to the real destination. + + $doit $rmcmd $dst + $doit $mvcmd $dsttmp $dst + + + exit 0 Index: llvm/lib/CodeGen/ELF/mkinstalldirs diff -c /dev/null llvm/lib/CodeGen/ELF/mkinstalldirs:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/mkinstalldirs Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,35 ---- + #!/bin/sh + # Make directory hierarchy. + # Written by Noah Friedman + # Public domain. + + defaultIFS=' + ' + IFS="${IFS-${defaultIFS}}" + + errstatus=0 + + for file in ${1+"$@"} ; do + oIFS="${IFS}" + # Some sh's can't handle IFS=/ for some reason. + IFS='%' + set - `echo ${file} | sed -e 's@/@%@g' -e 's@^%@/@'` + IFS="${oIFS}" + + pathcomp='' + + for d in ${1+"$@"} ; do + pathcomp="${pathcomp}${d}" + + if test ! -d "${pathcomp}"; then + echo "mkdir $pathcomp" 1>&2 + mkdir "${pathcomp}" || errstatus=$? + fi + + pathcomp="${pathcomp}/" + done + done + + exit $errstatus + + # eof Index: llvm/lib/CodeGen/ELF/stamp-h.in diff -c /dev/null llvm/lib/CodeGen/ELF/stamp-h.in:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/stamp-h.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1 ---- + timestamp From reid at x10sys.com Wed Jun 22 01:36:10 2005 From: reid at x10sys.com (Reid Spencer) Date: Wed, 22 Jun 2005 01:36:10 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/ELF/lib/32.fsize.c 32.getehdr.c 32.getphdr.c 32.getshdr.c 32.newehdr.c 32.newphdr.c 32.xlatetof.c 64.xlatetof.c Makefile.in assert.c begin.c byteswap.h checksum.c cntl.c cook.c data.c elf_repl.h end.c errmsg.c errno.c errors.h ext_types.h fill.c flag.c gelf.h gelfehdr.c gelfphdr.c gelfshdr.c gelftrans.c getarhdr.c getarsym.c getbase.c getdata.c getident.c getscn.c hash.c input.c kind.c libelf.h memset.c ndxscn.c newdata.c newscn.c next.c nextscn.c nlist.c nlist.h opt.delscn.c private.h rand.c rawdata.c rawfile.c strptr.c swap64.c sys_elf.h.in update.c verdef.h verdef_32_tof.c verdef_32_tom.c verdef_64_tof.c verdef_64_tom.c verneed.h version.c x.movscn.c x.remscn.c Message-ID: <200506220636.BAA04231@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/ELF/lib: 32.fsize.c added (r1.1) 32.getehdr.c added (r1.1) 32.getphdr.c added (r1.1) 32.getshdr.c added (r1.1) 32.newehdr.c added (r1.1) 32.newphdr.c added (r1.1) 32.xlatetof.c added (r1.1) 64.xlatetof.c added (r1.1) Makefile.in added (r1.1) assert.c added (r1.1) begin.c added (r1.1) byteswap.h added (r1.1) checksum.c added (r1.1) cntl.c added (r1.1) cook.c added (r1.1) data.c added (r1.1) elf_repl.h added (r1.1) end.c added (r1.1) errmsg.c added (r1.1) errno.c added (r1.1) errors.h added (r1.1) ext_types.h added (r1.1) fill.c added (r1.1) flag.c added (r1.1) gelf.h added (r1.1) gelfehdr.c added (r1.1) gelfphdr.c added (r1.1) gelfshdr.c added (r1.1) gelftrans.c added (r1.1) getarhdr.c added (r1.1) getarsym.c added (r1.1) getbase.c added (r1.1) getdata.c added (r1.1) getident.c added (r1.1) getscn.c added (r1.1) hash.c added (r1.1) input.c added (r1.1) kind.c added (r1.1) libelf.h added (r1.1) memset.c added (r1.1) ndxscn.c added (r1.1) newdata.c added (r1.1) newscn.c added (r1.1) next.c added (r1.1) nextscn.c added (r1.1) nlist.c added (r1.1) nlist.h added (r1.1) opt.delscn.c added (r1.1) private.h added (r1.1) rand.c added (r1.1) rawdata.c added (r1.1) rawfile.c added (r1.1) strptr.c added (r1.1) swap64.c added (r1.1) sys_elf.h.in added (r1.1) update.c added (r1.1) verdef.h added (r1.1) verdef_32_tof.c added (r1.1) verdef_32_tom.c added (r1.1) verdef_64_tof.c added (r1.1) verdef_64_tom.c added (r1.1) verneed.h added (r1.1) version.c added (r1.1) x.movscn.c added (r1.1) x.remscn.c added (r1.1) --- Log message: Adding libELF 0.8.5. This is the first baby step towards supporting direct generation of ELF files in LLVM. Its not clear at this point that all of the software added by this commit is actually needed. However, until requirements are solidified, I've included the whole thing. Note that this currently won't be built by the makefile system. Once an LLVM interface to this software is available, we'll start building libELF in order to provide the functionality. --- Diffs of the changes: (+10330 -0) 32.fsize.c | 155 ++++++++ 32.getehdr.c | 56 +++ 32.getphdr.c | 56 +++ 32.getshdr.c | 58 +++ 32.newehdr.c | 84 ++++ 32.newphdr.c | 107 ++++++ 32.xlatetof.c | 425 ++++++++++++++++++++++++ 64.xlatetof.c | 499 ++++++++++++++++++++++++++++ Makefile.in | 287 ++++++++++++++++ assert.c | 33 + begin.c | 431 ++++++++++++++++++++++++ byteswap.h | 95 +++++ checksum.c | 178 ++++++++++ cntl.c | 71 ++++ cook.c | 457 ++++++++++++++++++++++++++ data.c | 28 + elf_repl.h | 917 ++++++++++++++++++++++++++++++++++++++++++++++++++++ end.c | 122 ++++++ errmsg.c | 77 ++++ errno.c | 32 + errors.h | 98 +++++ ext_types.h | 334 +++++++++++++++++++ fill.c | 29 + flag.c | 92 +++++ gelf.h | 153 ++++++++ gelfehdr.c | 138 +++++++ gelfphdr.c | 146 ++++++++ gelfshdr.c | 123 +++++++ gelftrans.c | 407 +++++++++++++++++++++++ getarhdr.c | 37 ++ getarsym.c | 87 ++++ getbase.c | 33 + getdata.c | 157 ++++++++ getident.c | 48 ++ getscn.c | 48 ++ hash.c | 38 ++ input.c | 81 ++++ kind.c | 33 + libelf.h | 264 +++++++++++++++ memset.c | 52 ++ ndxscn.c | 33 + newdata.c | 56 +++ newscn.c | 120 ++++++ next.c | 42 ++ nextscn.c | 54 +++ nlist.c | 249 ++++++++++++++ nlist.h | 48 ++ opt.delscn.c | 205 +++++++++++ private.h | 399 ++++++++++++++++++++++ rand.c | 43 ++ rawdata.c | 89 +++++ rawfile.c | 52 ++ strptr.c | 144 ++++++++ swap64.c | 81 ++++ sys_elf.h.in | 127 +++++++ update.c | 977 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ verdef.h | 279 +++++++++++++++ verdef_32_tof.c | 53 +++ verdef_32_tom.c | 53 +++ verdef_64_tof.c | 53 +++ verdef_64_tom.c | 53 +++ verneed.h | 283 ++++++++++++++++ version.c | 40 ++ x.movscn.c | 112 ++++++ x.remscn.c | 119 ++++++ 65 files changed, 10330 insertions(+) Index: llvm/lib/CodeGen/ELF/lib/32.fsize.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.fsize.c:1.1 *** /dev/null Wed Jun 22 01:36:07 2005 --- llvm/lib/CodeGen/ELF/lib/32.fsize.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,155 ---- + /* + 32.fsize.c - implementation of the elf{32,64}_fsize(3) functions. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.fsize.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + const size_t + _elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2] = { + /* ELFCLASS32 */ + { + /* version 1 */ + { + { sizeof(unsigned char), sizeof(unsigned char) }, + { sizeof(Elf32_Addr), sizeof(__ext_Elf32_Addr) }, + { sizeof(Elf32_Dyn), sizeof(__ext_Elf32_Dyn) }, + { sizeof(Elf32_Ehdr), sizeof(__ext_Elf32_Ehdr) }, + { sizeof(Elf32_Half), sizeof(__ext_Elf32_Half) }, + { sizeof(Elf32_Off), sizeof(__ext_Elf32_Off) }, + { sizeof(Elf32_Phdr), sizeof(__ext_Elf32_Phdr) }, + { sizeof(Elf32_Rela), sizeof(__ext_Elf32_Rela) }, + { sizeof(Elf32_Rel), sizeof(__ext_Elf32_Rel) }, + { sizeof(Elf32_Shdr), sizeof(__ext_Elf32_Shdr) }, + { sizeof(Elf32_Sword), sizeof(__ext_Elf32_Sword) }, + { sizeof(Elf32_Sym), sizeof(__ext_Elf32_Sym) }, + { sizeof(Elf32_Word), sizeof(__ext_Elf32_Word) }, + { 0, 0 }, /* there is no Elf32_Sxword */ + { 0, 0 }, /* there is no Elf32_Xword */ + /* XXX: check Solaris values */ + { 0, 0 }, /* Elf32_Verdef/Verdaux size varies */ + { 0, 0 }, /* Elf32_Verneed/Vernaux size varies */ + }, + }, + #if __LIBELF64 + /* ELFCLASS64 */ + { + /* version 1 */ + { + { sizeof(unsigned char), sizeof(unsigned char) }, + { sizeof(Elf64_Addr), sizeof(__ext_Elf64_Addr) }, + { sizeof(Elf64_Dyn), sizeof(__ext_Elf64_Dyn) }, + { sizeof(Elf64_Ehdr), sizeof(__ext_Elf64_Ehdr) }, + { sizeof(Elf64_Half), sizeof(__ext_Elf64_Half) }, + { sizeof(Elf64_Off), sizeof(__ext_Elf64_Off) }, + { sizeof(Elf64_Phdr), sizeof(__ext_Elf64_Phdr) }, + { sizeof(Elf64_Rela), sizeof(__ext_Elf64_Rela) }, + { sizeof(Elf64_Rel), sizeof(__ext_Elf64_Rel) }, + { sizeof(Elf64_Shdr), sizeof(__ext_Elf64_Shdr) }, + { sizeof(Elf64_Sword), sizeof(__ext_Elf64_Sword) }, + { sizeof(Elf64_Sym), sizeof(__ext_Elf64_Sym) }, + { sizeof(Elf64_Word), sizeof(__ext_Elf64_Word) }, + { sizeof(Elf64_Sxword), sizeof(__ext_Elf64_Sxword) }, + { sizeof(Elf64_Xword), sizeof(__ext_Elf64_Xword) }, + /* XXX: check Solaris values */ + { 0, 0 }, /* Elf64_Verdef/Verdaux size varies */ + { 0, 0 }, /* Elf64_Verneed/Vernaux size varies */ + }, + }, + #endif /* __LIBELF64 */ + }; + + static size_t + _elf_fsize(unsigned cls, Elf_Type type, unsigned ver) { + size_t n = 0; + + if (!valid_version(ver)) { + seterr(ERROR_UNKNOWN_VERSION); + } + else if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + } + else if (!(n = _fsize(cls, ver, type))) { + seterr(ERROR_UNKNOWN_TYPE); + } + return n; + } + + size_t + elf32_fsize(Elf_Type type, size_t count, unsigned ver) { + return count * _elf_fsize(ELFCLASS32, type, ver); + } + + #if __LIBELF64 + + size_t + elf64_fsize(Elf_Type type, size_t count, unsigned ver) { + return count * _elf_fsize(ELFCLASS64, type, ver); + } + + size_t + gelf_fsize(Elf *elf, Elf_Type type, size_t count, unsigned ver) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (valid_class(elf->e_class)) { + return count * _elf_fsize(elf->e_class, type, ver); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + } + return 0; + } + + /* + * Extension: report memory size + */ + size_t + gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) { + size_t n; + + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (!valid_class(elf->e_class)) { + seterr(ERROR_UNKNOWN_CLASS); + } + else if (!valid_version(ver)) { + seterr(ERROR_UNKNOWN_VERSION); + } + else if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + } + else if (!(n = _msize(elf->e_class, ver, type))) { + seterr(ERROR_UNKNOWN_TYPE); + } + else { + return count * n; + } + } + return 0; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.getehdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.getehdr.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.getehdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,56 ---- + /* + 32.getehdr.c - implementation of the elf{32,64}_getehdr(3) functions. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.getehdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + char* + _elf_getehdr(Elf *elf, unsigned cls) { + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class != cls) { + seterr(ERROR_CLASSMISMATCH); + } + else if (elf->e_ehdr || _elf_cook(elf)) { + return elf->e_ehdr; + } + return NULL; + } + + Elf32_Ehdr* + elf32_getehdr(Elf *elf) { + return (Elf32_Ehdr*)_elf_getehdr(elf, ELFCLASS32); + } + + #if __LIBELF64 + + Elf64_Ehdr* + elf64_getehdr(Elf *elf) { + return (Elf64_Ehdr*)_elf_getehdr(elf, ELFCLASS64); + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.getphdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.getphdr.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.getphdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,56 ---- + /* + 32.getphdr.c - implementation of the elf{32,64}_getphdr(3) functions. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.getphdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + char* + _elf_getphdr(Elf *elf, unsigned cls) { + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class != cls) { + seterr(ERROR_CLASSMISMATCH); + } + else if (elf->e_ehdr || _elf_cook(elf)) { + return elf->e_phdr; + } + return NULL; + } + + Elf32_Phdr* + elf32_getphdr(Elf *elf) { + return (Elf32_Phdr*)_elf_getphdr(elf, ELFCLASS32); + } + + #if __LIBELF64 + + Elf64_Phdr* + elf64_getphdr(Elf *elf) { + return (Elf64_Phdr*)_elf_getphdr(elf, ELFCLASS64); + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.getshdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.getshdr.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.getshdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,58 ---- + /* + 32.getshdr.c - implementation of the elf{32,64}_getshdr(3) functions. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.getshdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf32_Shdr* + elf32_getshdr(Elf_Scn *scn) { + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf); + elf_assert(scn->s_elf->e_magic == ELF_MAGIC); + if (scn->s_elf->e_class == ELFCLASS32) { + return &scn->s_shdr32; + } + seterr(ERROR_CLASSMISMATCH); + return NULL; + } + + #if __LIBELF64 + + Elf64_Shdr* + elf64_getshdr(Elf_Scn *scn) { + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf); + elf_assert(scn->s_elf->e_magic == ELF_MAGIC); + if (scn->s_elf->e_class == ELFCLASS64) { + return &scn->s_shdr64; + } + seterr(ERROR_CLASSMISMATCH); + return NULL; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.newehdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.newehdr.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.newehdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,84 ---- + /* + 32.newehdr.c - implementation of the elf{32,64}_newehdr(3) functions. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.newehdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + static char* + _elf_newehdr(Elf *elf, unsigned cls) { + size_t size; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_readable) { + return _elf_getehdr(elf, cls); + } + else if (!elf->e_ehdr) { + size = _msize(cls, _elf_version, ELF_T_EHDR); + elf_assert(size); + if ((elf->e_ehdr = (char*)malloc(size))) { + memset(elf->e_ehdr, 0, size); + elf->e_free_ehdr = 1; + elf->e_ehdr_flags |= ELF_F_DIRTY; + elf->e_kind = ELF_K_ELF; + elf->e_class = cls; + return elf->e_ehdr; + } + seterr(ERROR_MEM_EHDR); + } + else if (elf->e_class != cls) { + seterr(ERROR_CLASSMISMATCH); + } + else { + elf_assert(elf->e_kind == ELF_K_ELF); + return elf->e_ehdr; + } + return NULL; + } + + Elf32_Ehdr* + elf32_newehdr(Elf *elf) { + return (Elf32_Ehdr*)_elf_newehdr(elf, ELFCLASS32); + } + + #if __LIBELF64 + + Elf64_Ehdr* + elf64_newehdr(Elf *elf) { + return (Elf64_Ehdr*)_elf_newehdr(elf, ELFCLASS64); + } + + unsigned long + gelf_newehdr(Elf *elf, int cls) { + if (!valid_class(cls) || !_msize(cls, _elf_version, ELF_T_EHDR)) { + seterr(ERROR_UNKNOWN_CLASS); + return 0; + } + if (!_elf_newehdr(elf, cls)) { + return 0; + } + return 1; /* really? */ + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.newphdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.newphdr.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.newphdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,107 ---- + /* + 32.newphdr.c - implementation of the elf{32,64}_newphdr(3) functions. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.newphdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + static char* + _elf_newphdr(Elf *elf, size_t count, unsigned cls) { + char *phdr = NULL; + size_t size; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (!elf->e_ehdr && !elf->e_readable) { + seterr(ERROR_NOEHDR); + } + else if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class != cls) { + seterr(ERROR_CLASSMISMATCH); + } + else if (elf->e_ehdr || _elf_cook(elf)) { + size = _msize(cls, _elf_version, ELF_T_PHDR); + elf_assert(size); + if (count) { + if (!(phdr = (char*)malloc(count * size))) { + seterr(ERROR_MEM_PHDR); + return NULL; + } + memset(phdr, 0, count * size); + } + elf_assert(elf->e_ehdr); + if (cls == ELFCLASS32) { + ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum = elf->e_phnum = count; + } + #if __LIBELF64 + else if (cls == ELFCLASS64) { + ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum = elf->e_phnum = count; + } + #endif /* __LIBELF64 */ + else { + seterr(ERROR_UNIMPLEMENTED); + if (phdr) { + free(phdr); + } + return NULL; + } + if (elf->e_free_phdr) { + elf_assert(elf->e_phdr); + free(elf->e_phdr); + } + elf->e_phdr = phdr; + elf->e_free_phdr = phdr ? 1 : 0; + elf->e_phdr_flags |= ELF_F_DIRTY; + elf->e_ehdr_flags |= ELF_F_DIRTY; + return phdr; + } + return NULL; + } + + Elf32_Phdr* + elf32_newphdr(Elf *elf, size_t count) { + return (Elf32_Phdr*)_elf_newphdr(elf, count, ELFCLASS32); + } + + #if __LIBELF64 + + Elf64_Phdr* + elf64_newphdr(Elf *elf, size_t count) { + return (Elf64_Phdr*)_elf_newphdr(elf, count, ELFCLASS64); + } + + unsigned long + gelf_newphdr(Elf *elf, size_t phnum) { + if (!valid_class(elf->e_class)) { + seterr(ERROR_UNKNOWN_CLASS); + return 0; + } + if (!_elf_newphdr(elf, phnum, elf->e_class)) { + return 0; + } + return 1; /* really? */ + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/32.xlatetof.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/32.xlatetof.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/32.xlatetof.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,425 ---- + /* + 32.xlatetof.c - implementation of the elf32_xlateto[fm](3) functions. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 32.xlatetof.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + /* + * Ugly, ugly + */ + #define x + #if defined/**/x + # define Cat2(a,b)a##b + # define Cat3(a,b,c)a##b##c + # define Ex1(m1,m2,a,b)m1##m2(a##b) + # define Ex2(m1,m2,a,b,c)m1##m2(a,b##c) + #else + # define Cat2(a,b)a/**/b + # define Cat3(a,b,c)a/**/b/**/c + # define Ex1(m1,m2,a,b)m1/**/m2(a/**/b) + # define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c) + #endif + #undef x + + /* + * auxiliary macros for execution order reversal + */ + #define seq_forw(a,b) a b + #define seq_back(a,b) b a + + /* + * function instantiator + */ + #define copy_type_e_io(name,e,io,tfrom,tto,copy) \ + static size_t \ + Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) { \ + n /= sizeof(tfrom); \ + if (n && dst) { \ + const tfrom *from = (const tfrom*)src; \ + tto *to = (tto*)dst; \ + size_t i; \ + \ + if (sizeof(tfrom) < sizeof(tto)) { \ + from += n; \ + to += n; \ + for (i = 0; i < n; i++) { \ + --from; \ + --to; \ + copy(e,io,seq_back) \ + } \ + } \ + else { \ + for (i = 0; i < n; i++) { \ + copy(e,io,seq_forw) \ + from++; \ + to++; \ + } \ + } \ + } \ + return n * sizeof(tto); \ + } + + #define copy_type_e(name,e,type,copy) \ + copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy) \ + copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy) + + /* + * master function instantiator + */ + #define copy_type(name,version,type,copy) \ + copy_type_e(Cat3(name,L,version),L,type,copy) \ + copy_type_e(Cat3(name,M,version),M,type,copy) + + /* + * scalar copying + */ + #define copy_scalar_tom(type) *to = Cat2(__load_,type)(*from); + #define copy_scalar_tof(type) Cat2(__store_,type)(*to, *from); + + /* + * structure member copying + */ + #define copy_tom(mb,type) to->mb = Cat2(__load_,type)(from->mb); + #define copy_tof(mb,type) Cat2(__store_,type)(to->mb, from->mb); + + /* + * structure member copying (direction independent) + */ + #define copy_byte(e,io,mb) to->mb = from->mb; + #define copy_addr(e,io,mb) Ex2(copy_,io,mb,u32,e) + #define copy_half(e,io,mb) Ex2(copy_,io,mb,u16,e) + #define copy_off(e,io,mb) Ex2(copy_,io,mb,u32,e) + #define copy_sword(e,io,mb) Ex2(copy_,io,mb,i32,e) + #define copy_word(e,io,mb) Ex2(copy_,io,mb,u32,e) + #define copy_arr(e,io,mb) \ + array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb)); + + /* + * scalar copying (direction independent) + * these macros are used as `copy' arguments to copy_type() + */ + #define copy_addr_11(e,io,seq) Ex1(copy_scalar_,io,u32,e) + #define copy_half_11(e,io,seq) Ex1(copy_scalar_,io,u16,e) + #define copy_off_11(e,io,seq) Ex1(copy_scalar_,io,u32,e) + #define copy_sword_11(e,io,seq) Ex1(copy_scalar_,io,i32,e) + #define copy_word_11(e,io,seq) Ex1(copy_scalar_,io,u32,e) + + /* + * structure copying (direction independent) + * these macros are used as `copy' arguments to copy_type() + */ + #define copy_dyn_11(e,io,seq) \ + seq(copy_sword(e,io,d_tag), \ + seq(copy_addr(e,io,d_un.d_ptr), \ + nullcopy)) + #define copy_ehdr_11(e,io,seq) \ + seq(copy_arr(e,io,e_ident), \ + seq(copy_half(e,io,e_type), \ + seq(copy_half(e,io,e_machine), \ + seq(copy_word(e,io,e_version), \ + seq(copy_addr(e,io,e_entry), \ + seq(copy_off(e,io,e_phoff), \ + seq(copy_off(e,io,e_shoff), \ + seq(copy_word(e,io,e_flags), \ + seq(copy_half(e,io,e_ehsize), \ + seq(copy_half(e,io,e_phentsize), \ + seq(copy_half(e,io,e_phnum), \ + seq(copy_half(e,io,e_shentsize), \ + seq(copy_half(e,io,e_shnum), \ + seq(copy_half(e,io,e_shstrndx), \ + nullcopy)))))))))))))) + #define copy_phdr_11(e,io,seq) \ + seq(copy_word(e,io,p_type), \ + seq(copy_off(e,io,p_offset), \ + seq(copy_addr(e,io,p_vaddr), \ + seq(copy_addr(e,io,p_paddr), \ + seq(copy_word(e,io,p_filesz), \ + seq(copy_word(e,io,p_memsz), \ + seq(copy_word(e,io,p_flags), \ + seq(copy_word(e,io,p_align), \ + nullcopy)))))))) + #define copy_rela_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_word(e,io,r_info), \ + seq(copy_sword(e,io,r_addend), \ + nullcopy))) + #define copy_rel_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_word(e,io,r_info), \ + nullcopy)) + #define copy_shdr_11(e,io,seq) \ + seq(copy_word(e,io,sh_name), \ + seq(copy_word(e,io,sh_type), \ + seq(copy_word(e,io,sh_flags), \ + seq(copy_addr(e,io,sh_addr), \ + seq(copy_off(e,io,sh_offset), \ + seq(copy_word(e,io,sh_size), \ + seq(copy_word(e,io,sh_link), \ + seq(copy_word(e,io,sh_info), \ + seq(copy_word(e,io,sh_addralign), \ + seq(copy_word(e,io,sh_entsize), \ + nullcopy)))))))))) + #define copy_sym_11(e,io,seq) \ + seq(copy_word(e,io,st_name), \ + seq(copy_addr(e,io,st_value), \ + seq(copy_word(e,io,st_size), \ + seq(copy_byte(e,io,st_info), \ + seq(copy_byte(e,io,st_other), \ + seq(copy_half(e,io,st_shndx), \ + nullcopy)))))) + + #define nullcopy /**/ + + static size_t + byte_copy(unsigned char *dst, const unsigned char *src, size_t n) { + if (n && dst && dst != src) { + #if HAVE_BROKEN_MEMMOVE + size_t i; + + if (dst >= src + n || dst + n <= src) { + memcpy(dst, src, n); + } + else if (dst < src) { + for (i = 0; i < n; i++) { + dst[i] = src[i]; + } + } + else { + for (i = n; --i; ) { + dst[i] = src[i]; + } + } + #else /* HAVE_BROKEN_MEMMOVE */ + memmove(dst, src, n); + #endif /* HAVE_BROKEN_MEMMOVE */ + } + return n; + } + + static void + array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) { + byte_copy(dst, src, dlen < slen ? dlen : slen); + if (dlen > slen) { + memset(dst + slen, 0, dlen - slen); + } + } + + /* + * instantiate copy functions + */ + copy_type(addr_32,_,Elf32_Addr,copy_addr_11) + copy_type(half_32,_,Elf32_Half,copy_half_11) + copy_type(off_32,_,Elf32_Off,copy_off_11) + copy_type(sword_32,_,Elf32_Sword,copy_sword_11) + copy_type(word_32,_,Elf32_Word,copy_word_11) + copy_type(dyn_32,11,Elf32_Dyn,copy_dyn_11) + copy_type(ehdr_32,11,Elf32_Ehdr,copy_ehdr_11) + copy_type(phdr_32,11,Elf32_Phdr,copy_phdr_11) + copy_type(rela_32,11,Elf32_Rela,copy_rela_11) + copy_type(rel_32,11,Elf32_Rel,copy_rel_11) + copy_type(shdr_32,11,Elf32_Shdr,copy_shdr_11) + copy_type(sym_32,11,Elf32_Sym,copy_sym_11) + + typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t); + typedef xlator xltab[ELF_T_NUM][2]; + + /* + * translation table (32-bit, version 1 -> version 1) + */ + #if PIC + static xltab + #else /* PIC */ + static const xltab + #endif /* PIC */ + xlate32_11[/*encoding*/] = { + { + { byte_copy, byte_copy }, + { addr_32L__tom, addr_32L__tof }, + { dyn_32L11_tom, dyn_32L11_tof }, + { ehdr_32L11_tom, ehdr_32L11_tof }, + { half_32L__tom, half_32L__tof }, + { off_32L__tom, off_32L__tof }, + { phdr_32L11_tom, phdr_32L11_tof }, + { rela_32L11_tom, rela_32L11_tof }, + { rel_32L11_tom, rel_32L11_tof }, + { shdr_32L11_tom, shdr_32L11_tof }, + { sword_32L__tom, sword_32L__tof }, + { sym_32L11_tom, sym_32L11_tof }, + { word_32L__tom, word_32L__tof }, + { NULL, NULL }, /* there is no Sxword */ + { NULL, NULL }, /* there is no Xword */ + #if __LIBELF_SYMBOL_VERSIONS + { _elf_verdef_32L11_tom, _elf_verdef_32L11_tof }, + { _elf_verneed_32L11_tom, _elf_verneed_32L11_tof }, + #else /* __LIBELF_SYMBOL_VERSIONS */ + { NULL, NULL }, + { NULL, NULL }, + #endif /* __LIBELF_SYMBOL_VERSIONS */ + }, + { + { byte_copy, byte_copy }, + { addr_32M__tom, addr_32M__tof }, + { dyn_32M11_tom, dyn_32M11_tof }, + { ehdr_32M11_tom, ehdr_32M11_tof }, + { half_32M__tom, half_32M__tof }, + { off_32M__tom, off_32M__tof }, + { phdr_32M11_tom, phdr_32M11_tof }, + { rela_32M11_tom, rela_32M11_tof }, + { rel_32M11_tom, rel_32M11_tof }, + { shdr_32M11_tom, shdr_32M11_tof }, + { sword_32M__tom, sword_32M__tof }, + { sym_32M11_tom, sym_32M11_tof }, + { word_32M__tom, word_32M__tof }, + { NULL, NULL }, /* there is no Sxword */ + { NULL, NULL }, /* there is no Xword */ + #if __LIBELF_SYMBOL_VERSIONS + { _elf_verdef_32M11_tom, _elf_verdef_32M11_tof }, + { _elf_verneed_32M11_tom, _elf_verneed_32M11_tof }, + #else /* __LIBELF_SYMBOL_VERSIONS */ + { NULL, NULL }, + { NULL, NULL }, + #endif /* __LIBELF_SYMBOL_VERSIONS */ + }, + }; + + /* + * main translation table (32-bit) + */ + #if PIC + static xltab* + #else /* PIC */ + static const xltab *const + #endif /* PIC */ + xlate32[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = { + { xlate32_11, }, + }; + + #define translator(sv,dv,enc,type,d) \ + (xlate32[(sv) - EV_NONE - 1] \ + [(dv) - EV_NONE - 1] \ + [(enc) - ELFDATA2LSB] \ + [(type) - ELF_T_BYTE] \ + [d]) + + /* + * destination buffer size + */ + size_t + _elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) { + Elf_Type type = src->d_type; + unsigned sv = src->d_version; + xlator op; + + if (!valid_version(sv) || !valid_version(dv)) { + seterr(ERROR_UNKNOWN_VERSION); + return (size_t)-1; + } + if (tof) { + /* + * Encoding doesn't really matter (the translator only looks at + * the source, which resides in memory), but we need a proper + * encoding to select a translator... + */ + encode = ELFDATA2LSB; + } + else if (!valid_encoding(encode)) { + seterr(ERROR_UNKNOWN_ENCODING); + return (size_t)-1; + } + if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + return (size_t)-1; + } + if (!(op = translator(sv, dv, encode, type, tof))) { + seterr(ERROR_UNKNOWN_TYPE); + return (size_t)-1; + } + return (*op)(NULL, src->d_buf, src->d_size); + } + + /* + * direction-independent translation + */ + static Elf_Data* + elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) { + Elf_Type type; + int dv; + int sv; + size_t dsize; + size_t tmp; + xlator op; + + if (!src || !dst) { + return NULL; + } + if (!src->d_buf || !dst->d_buf) { + seterr(ERROR_NULLBUF); + return NULL; + } + if (!valid_encoding(encode)) { + seterr(ERROR_UNKNOWN_ENCODING); + return NULL; + } + sv = src->d_version; + dv = dst->d_version; + if (!valid_version(sv) || !valid_version(dv)) { + seterr(ERROR_UNKNOWN_VERSION); + return NULL; + } + type = src->d_type; + if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + return NULL; + } + op = translator(sv, dv, encode, type, tof); + if (!op) { + seterr(ERROR_UNKNOWN_TYPE); + return NULL; + } + dsize = (*op)(NULL, src->d_buf, src->d_size); + if (dst->d_size < dsize) { + seterr(ERROR_DST2SMALL); + return NULL; + } + if (dsize) { + tmp = (*op)(dst->d_buf, src->d_buf, src->d_size); + elf_assert(tmp == dsize); + } + dst->d_size = dsize; + dst->d_type = type; + return dst; + } + + /* + * finally, the "official" translation functions + */ + Elf_Data* + elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) { + return elf32_xlate(dst, src, encode, 0); + } + + Elf_Data* + elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) { + return elf32_xlate(dst, src, encode, 1); + } Index: llvm/lib/CodeGen/ELF/lib/64.xlatetof.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/64.xlatetof.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/64.xlatetof.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,499 ---- + /* + 64.xlatetof.c - implementation of the elf64_xlateto[fm](3) functions. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: 64.xlatetof.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + /* + * Ugly, ugly + */ + #define x + #if defined/**/x + # define Cat2(a,b)a##b + # define Cat3(a,b,c)a##b##c + # define Ex1(m1,m2,a,b)m1##m2(a##b) + # define Ex2(m1,m2,a,b,c)m1##m2(a,b##c) + #else + # define Cat2(a,b)a/**/b + # define Cat3(a,b,c)a/**/b/**/c + # define Ex1(m1,m2,a,b)m1/**/m2(a/**/b) + # define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c) + #endif + #undef x + + /* + * auxiliary macros for execution order reversal + */ + #define seq_forw(a,b) a b + #define seq_back(a,b) b a + + /* + * function instantiator + */ + #define copy_type_e_io(name,e,io,tfrom,tto,copy) \ + static size_t \ + Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) { \ + n /= sizeof(tfrom); \ + if (n && dst) { \ + const tfrom *from = (const tfrom*)src; \ + tto *to = (tto*)dst; \ + size_t i; \ + \ + if (sizeof(tfrom) < sizeof(tto)) { \ + from += n; \ + to += n; \ + for (i = 0; i < n; i++) { \ + --from; \ + --to; \ + copy(e,io,seq_back) \ + } \ + } \ + else { \ + for (i = 0; i < n; i++) { \ + copy(e,io,seq_forw) \ + from++; \ + to++; \ + } \ + } \ + } \ + return n * sizeof(tto); \ + } + + #define copy_type_e(name,e,type,copy) \ + copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy) \ + copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy) + + /* + * master function instantiator + */ + #define copy_type(name,version,type,copy) \ + copy_type_e(Cat3(name,L,version),L,type,copy) \ + copy_type_e(Cat3(name,M,version),M,type,copy) + + /* + * scalar copying + */ + #define copy_scalar_tom(type) *to = Cat2(__load_,type)(*from); + #define copy_scalar_tof(type) Cat2(__store_,type)(*to, *from); + + /* + * structure member copying + */ + #define copy_tom(mb,type) to->mb = Cat2(__load_,type)(from->mb); + #define copy_tof(mb,type) Cat2(__store_,type)(to->mb, from->mb); + + /* + * structure member copying (direction independent) + */ + #define copy_byte(e,io,mb) to->mb = from->mb; + #define copy_addr(e,io,mb) Ex2(copy_,io,mb,u64,e) + #define copy_half(e,io,mb) Ex2(copy_,io,mb,u16,e) + #define copy_off(e,io,mb) Ex2(copy_,io,mb,u64,e) + #define copy_sword(e,io,mb) Ex2(copy_,io,mb,i32,e) + #define copy_word(e,io,mb) Ex2(copy_,io,mb,u32,e) + #define copy_sxword(e,io,mb) Ex2(copy_,io,mb,i64,e) + #define copy_xword(e,io,mb) Ex2(copy_,io,mb,u64,e) + #define copy_arr(e,io,mb) \ + array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb)); + + /* + * scalar copying (direction independent) + * these macros are used as `copy' arguments to copy_type() + */ + #define copy_addr_11(e,io,seq) Ex1(copy_scalar_,io,u64,e) + #define copy_half_11(e,io,seq) Ex1(copy_scalar_,io,u16,e) + #define copy_off_11(e,io,seq) Ex1(copy_scalar_,io,u64,e) + #define copy_sword_11(e,io,seq) Ex1(copy_scalar_,io,i32,e) + #define copy_word_11(e,io,seq) Ex1(copy_scalar_,io,u32,e) + #define copy_sxword_11(e,io,seq)Ex1(copy_scalar_,io,i64,e) + #define copy_xword_11(e,io,seq) Ex1(copy_scalar_,io,u64,e) + + /* + * structure copying (direction independent) + * these macros are used as `copy' arguments to copy_type() + */ + #define copy_dyn_11(e,io,seq) \ + seq(copy_xword(e,io,d_tag), \ + seq(copy_addr(e,io,d_un.d_ptr), \ + nullcopy)) + #define copy_ehdr_11(e,io,seq) \ + seq(copy_arr(e,io,e_ident), \ + seq(copy_half(e,io,e_type), \ + seq(copy_half(e,io,e_machine), \ + seq(copy_word(e,io,e_version), \ + seq(copy_addr(e,io,e_entry), \ + seq(copy_off(e,io,e_phoff), \ + seq(copy_off(e,io,e_shoff), \ + seq(copy_word(e,io,e_flags), \ + seq(copy_half(e,io,e_ehsize), \ + seq(copy_half(e,io,e_phentsize), \ + seq(copy_half(e,io,e_phnum), \ + seq(copy_half(e,io,e_shentsize), \ + seq(copy_half(e,io,e_shnum), \ + seq(copy_half(e,io,e_shstrndx), \ + nullcopy)))))))))))))) + #define copy_phdr_11(e,io,seq) \ + seq(copy_word(e,io,p_type), \ + seq(copy_word(e,io,p_flags), \ + seq(copy_off(e,io,p_offset), \ + seq(copy_addr(e,io,p_vaddr), \ + seq(copy_addr(e,io,p_paddr), \ + seq(copy_xword(e,io,p_filesz), \ + seq(copy_xword(e,io,p_memsz), \ + seq(copy_xword(e,io,p_align), \ + nullcopy)))))))) + #if __LIBELF64_IRIX + #define copy_rela_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_word(e,io,r_sym), \ + seq(copy_byte(e,io,r_ssym), \ + seq(copy_byte(e,io,r_type3), \ + seq(copy_byte(e,io,r_type2), \ + seq(copy_byte(e,io,r_type), \ + seq(copy_sxword(e,io,r_addend), \ + nullcopy))))))) + #define copy_rel_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_word(e,io,r_sym), \ + seq(copy_byte(e,io,r_ssym), \ + seq(copy_byte(e,io,r_type3), \ + seq(copy_byte(e,io,r_type2), \ + seq(copy_byte(e,io,r_type), \ + nullcopy)))))) + #else /* __LIBELF64_IRIX */ + #define copy_rela_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_xword(e,io,r_info), \ + seq(copy_sxword(e,io,r_addend), \ + nullcopy))) + #define copy_rel_11(e,io,seq) \ + seq(copy_addr(e,io,r_offset), \ + seq(copy_xword(e,io,r_info), \ + nullcopy)) + #endif /* __LIBELF64_IRIX */ + #define copy_shdr_11(e,io,seq) \ + seq(copy_word(e,io,sh_name), \ + seq(copy_word(e,io,sh_type), \ + seq(copy_xword(e,io,sh_flags), \ + seq(copy_addr(e,io,sh_addr), \ + seq(copy_off(e,io,sh_offset), \ + seq(copy_xword(e,io,sh_size), \ + seq(copy_word(e,io,sh_link), \ + seq(copy_word(e,io,sh_info), \ + seq(copy_xword(e,io,sh_addralign), \ + seq(copy_xword(e,io,sh_entsize), \ + nullcopy)))))))))) + #define copy_sym_11(e,io,seq) \ + seq(copy_word(e,io,st_name), \ + seq(copy_byte(e,io,st_info), \ + seq(copy_byte(e,io,st_other), \ + seq(copy_half(e,io,st_shndx), \ + seq(copy_addr(e,io,st_value), \ + seq(copy_xword(e,io,st_size), \ + nullcopy)))))) + + #define nullcopy /**/ + + static size_t + byte_copy(unsigned char *dst, const unsigned char *src, size_t n) { + if (n && dst && dst != src) { + #if HAVE_BROKEN_MEMMOVE + size_t i; + + if (dst >= src + n || dst + n <= src) { + memcpy(dst, src, n); + } + else if (dst < src) { + for (i = 0; i < n; i++) { + dst[i] = src[i]; + } + } + else { + for (i = n; --i; ) { + dst[i] = src[i]; + } + } + #else /* HAVE_BROKEN_MEMMOVE */ + memmove(dst, src, n); + #endif /* HAVE_BROKEN_MEMMOVE */ + } + return n; + } + + static void + array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) { + byte_copy(dst, src, dlen < slen ? dlen : slen); + if (dlen > slen) { + memset(dst + slen, 0, dlen - slen); + } + } + + /* + * instantiate copy functions + */ + copy_type(addr_64,_,Elf64_Addr,copy_addr_11) + copy_type(half_64,_,Elf64_Half,copy_half_11) + copy_type(off_64,_,Elf64_Off,copy_off_11) + copy_type(sword_64,_,Elf64_Sword,copy_sword_11) + copy_type(word_64,_,Elf64_Word,copy_word_11) + copy_type(sxword_64,_,Elf64_Sxword,copy_sxword_11) + copy_type(xword_64,_,Elf64_Xword,copy_xword_11) + copy_type(dyn_64,11,Elf64_Dyn,copy_dyn_11) + copy_type(ehdr_64,11,Elf64_Ehdr,copy_ehdr_11) + copy_type(phdr_64,11,Elf64_Phdr,copy_phdr_11) + copy_type(rela_64,11,Elf64_Rela,copy_rela_11) + copy_type(rel_64,11,Elf64_Rel,copy_rel_11) + copy_type(shdr_64,11,Elf64_Shdr,copy_shdr_11) + copy_type(sym_64,11,Elf64_Sym,copy_sym_11) + + typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t); + typedef xlator xltab[ELF_T_NUM][2]; + + /* + * translation table (64-bit, version 1 -> version 1) + */ + #if PIC + static xltab + #else /* PIC */ + static const xltab + #endif /* PIC */ + xlate64_11[/*encoding*/] = { + { + { byte_copy, byte_copy }, + { addr_64L__tom, addr_64L__tof }, + { dyn_64L11_tom, dyn_64L11_tof }, + { ehdr_64L11_tom, ehdr_64L11_tof }, + { half_64L__tom, half_64L__tof }, + { off_64L__tom, off_64L__tof }, + { phdr_64L11_tom, phdr_64L11_tof }, + { rela_64L11_tom, rela_64L11_tof }, + { rel_64L11_tom, rel_64L11_tof }, + { shdr_64L11_tom, shdr_64L11_tof }, + { sword_64L__tom, sword_64L__tof }, + { sym_64L11_tom, sym_64L11_tof }, + { word_64L__tom, word_64L__tof }, + { sxword_64L__tom, sxword_64L__tof }, + { xword_64L__tom, xword_64L__tof }, + #if __LIBELF_SYMBOL_VERSIONS + { _elf_verdef_64L11_tom, _elf_verdef_64L11_tof }, + { _elf_verneed_64L11_tom, _elf_verneed_64L11_tof }, + #else /* __LIBELF_SYMBOL_VERSIONS */ + { NULL, NULL }, + { NULL, NULL }, + #endif /* __LIBELF_SYMBOL_VERSIONS */ + }, + { + { byte_copy, byte_copy }, + { addr_64M__tom, addr_64M__tof }, + { dyn_64M11_tom, dyn_64M11_tof }, + { ehdr_64M11_tom, ehdr_64M11_tof }, + { half_64M__tom, half_64M__tof }, + { off_64M__tom, off_64M__tof }, + { phdr_64M11_tom, phdr_64M11_tof }, + { rela_64M11_tom, rela_64M11_tof }, + { rel_64M11_tom, rel_64M11_tof }, + { shdr_64M11_tom, shdr_64M11_tof }, + { sword_64M__tom, sword_64M__tof }, + { sym_64M11_tom, sym_64M11_tof }, + { word_64M__tom, word_64M__tof }, + { sxword_64M__tom, sxword_64M__tof }, + { xword_64M__tom, xword_64M__tof }, + #if __LIBELF_SYMBOL_VERSIONS + { _elf_verdef_64M11_tom, _elf_verdef_64M11_tof }, + { _elf_verneed_64M11_tom, _elf_verneed_64M11_tof }, + #else /* __LIBELF_SYMBOL_VERSIONS */ + { NULL, NULL }, + { NULL, NULL }, + #endif /* __LIBELF_SYMBOL_VERSIONS */ + }, + }; + + /* + * main translation table (64-bit) + */ + #if PIC + static xltab* + #else /* PIC */ + static const xltab *const + #endif /* PIC */ + xlate64[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = { + { xlate64_11, }, + }; + + #define translator(sv,dv,enc,type,d) \ + (xlate64[(sv) - EV_NONE - 1] \ + [(dv) - EV_NONE - 1] \ + [(enc) - ELFDATA2LSB] \ + [(type) - ELF_T_BYTE] \ + [d]) + + /* + * destination buffer size + */ + size_t + _elf64_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) { + Elf_Type type = src->d_type; + unsigned sv = src->d_version; + xlator op; + + if (!valid_version(sv) || !valid_version(dv)) { + seterr(ERROR_UNKNOWN_VERSION); + return (size_t)-1; + } + if (tof) { + /* + * Encoding doesn't really matter (the translator only looks at + * the source, which resides in memory), but we need a proper + * encoding to select a translator... + */ + encode = ELFDATA2LSB; + } + else if (!valid_encoding(encode)) { + seterr(ERROR_UNKNOWN_ENCODING); + return (size_t)-1; + } + if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + return (size_t)-1; + } + if (!(op = translator(sv, dv, encode, type, tof))) { + seterr(ERROR_UNKNOWN_TYPE); + return (size_t)-1; + } + return (*op)(NULL, src->d_buf, src->d_size); + } + + /* + * direction-independent translation + */ + static Elf_Data* + elf64_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) { + Elf_Type type; + int dv; + int sv; + size_t dsize; + size_t tmp; + xlator op; + + if (!src || !dst) { + return NULL; + } + if (!src->d_buf || !dst->d_buf) { + seterr(ERROR_NULLBUF); + return NULL; + } + if (!valid_encoding(encode)) { + seterr(ERROR_UNKNOWN_ENCODING); + return NULL; + } + sv = src->d_version; + dv = dst->d_version; + if (!valid_version(sv) || !valid_version(dv)) { + seterr(ERROR_UNKNOWN_VERSION); + return NULL; + } + type = src->d_type; + if (!valid_type(type)) { + seterr(ERROR_UNKNOWN_TYPE); + return NULL; + } + op = translator(sv, dv, encode, type, tof); + if (!op) { + seterr(ERROR_UNKNOWN_TYPE); + return NULL; + } + dsize = (*op)(NULL, src->d_buf, src->d_size); + if (dst->d_size < dsize) { + seterr(ERROR_DST2SMALL); + return NULL; + } + if (dsize) { + tmp = (*op)(dst->d_buf, src->d_buf, src->d_size); + elf_assert(tmp == dsize); + } + dst->d_size = dsize; + dst->d_type = type; + return dst; + } + + /* + * finally, the "official" translation functions + */ + Elf_Data* + elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) { + return elf64_xlate(dst, src, encode, 0); + } + + Elf_Data* + elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) { + return elf64_xlate(dst, src, encode, 1); + } + + Elf_Data* + gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class == ELFCLASS32) { + return elf32_xlatetom(dst, src, encode); + } + else if (elf->e_class == ELFCLASS64) { + return elf64_xlatetom(dst, src, encode); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + } + return NULL; + } + + Elf_Data* + gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class == ELFCLASS32) { + return elf32_xlatetof(dst, src, encode); + } + else if (elf->e_class == ELFCLASS64) { + return elf64_xlatetof(dst, src, encode); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + } + return NULL; + } + + #endif /* __LIBELF64__ */ Index: llvm/lib/CodeGen/ELF/lib/Makefile.in diff -c /dev/null llvm/lib/CodeGen/ELF/lib/Makefile.in:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/Makefile.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,287 ---- + # lib/Makefile for libelf. + # Copyright (C) 1995 - 2003 Michael Riepe + # + # This library is free software; you can redistribute it and/or + # modify it under the terms of the GNU Library General Public + # License as published by the Free Software Foundation; either + # version 2 of the License, or (at your option) any later version. + # + # This library 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 + # Library General Public License for more details. + # + # You should have received a copy of the GNU Library General Public + # License along with this library; if not, write to the Free Software + # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + # @(#) $Id: Makefile.in,v 1.1 2005/06/22 06:35:57 reid Exp $ + + instroot = + + prefix = @prefix@ + exec_prefix = @exec_prefix@ + libdir = @libdir@ + includedir = @includedir@ + installdirs = $(libdir) $(includedir) $(includedir)/libelf + + CC = @CC@ + LD = @LD@ + AR = ar + MV = mv -f + RM = rm -f + LN_S = @LN_S@ + RANLIB = @RANLIB@ + INSTALL = @INSTALL@ + INSTALL_DATA = @INSTALL_DATA@ + INSTALL_PROGRAM = @INSTALL_PROGRAM@ + + CFLAGS = @CFLAGS@ + CPPFLAGS = @CPPFLAGS@ + DEFS = -DHAVE_CONFIG_H + LDFLAGS = @LDFLAGS@ + LIBS = @LIBS@ + DEPSHLIBS = @DEPSHLIBS@ + + DO_SHLIB = @DO_SHLIB@ + PICFLAGS = @PICFLAGS@ + SHLIB_SFX = @SHLIB_SFX@ + SHLINK_SFX = @SHLINK_SFX@ + SONAME_SFX = @SONAME_SFX@ + LINK_SHLIB = @LINK_SHLIB@ + INSTALL_SHLIB = @INSTALL_SHLIB@ + + SHLIB = libelf$(SHLIB_SFX) + SHLINK = libelf$(SHLINK_SFX) + SONAME = libelf$(SONAME_SFX) + + # install includes in includedir? + DO_COMPAT = @DO_COMPAT@ + + COMPILE = $(CC) -c $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(XCFLAGS) + + # no user serviceable parts below + + PACKAGE = @PACKAGE@ + VERSION = @VERSION@ + MAJOR = @MAJOR@ + + SHELL = /bin/sh + @SET_MAKE@ + + srcdir = @srcdir@ + top_srcdir = @top_srcdir@ + VPATH = @srcdir@ + + topdir = .. + subdir = lib + + .SUFFIXES: + .SUFFIXES: .c .o + .c.o: + @$(RM) $@ pic/$@ + if test -n "$(PICFLAGS)"; then \ + $(COMPILE) $(PICFLAGS) $< && $(MV) $@ pic/$@; \ + else true; fi + $(COMPILE) $< + + INCLUDES = -I$(topdir) -I. -I$(srcdir) + + # generic sources + SRCS1 = begin.c cntl.c end.c errmsg.c errno.c fill.c flag.c getarhdr.c \ + getarsym.c getbase.c getdata.c getident.c getscn.c hash.c kind.c \ + ndxscn.c newdata.c newscn.c next.c nextscn.c rand.c rawdata.c \ + rawfile.c strptr.c update.c version.c checksum.c + OBJS1 = begin.o cntl.o end.o errmsg.o errno.o fill.o flag.o getarhdr.o \ + getarsym.o getbase.o getdata.o getident.o getscn.o hash.o kind.o \ + ndxscn.o newdata.o newscn.o next.o nextscn.o rand.o rawdata.o \ + rawfile.o strptr.o update.o version.o checksum.o + + # 32-bit sources + SRCS2 = 32.fsize.c 32.getehdr.c 32.getphdr.c 32.getshdr.c 32.newehdr.c \ + 32.newphdr.c 32.xlatetof.c + OBJS2 = 32.fsize.o 32.getehdr.o 32.getphdr.o 32.getshdr.o 32.newehdr.o \ + 32.newphdr.o 32.xlatetof.o + + # support + SRCS3 = cook.c data.c input.c assert.c + OBJS3 = cook.o data.o input.o assert.o + + # nlist + SRCS4 = nlist.c + OBJS4 = nlist.o + + # opt + SRCS5 = opt.delscn.c x.remscn.c x.movscn.c + OBJS5 = opt.delscn.o x.remscn.o x.movscn.o + + # 64-bit sources + SRCS64 = 64.xlatetof.c gelfehdr.c gelfphdr.c gelfshdr.c gelftrans.c swap64.c + OBJS64 = 64.xlatetof.o gelfehdr.o gelfphdr.o gelfshdr.o gelftrans.o swap64.o + + # Versioning sources + SRCS_V = verdef_32_tof.c verdef_32_tom.c verdef_64_tof.c verdef_64_tom.c + OBJS_V = verdef_32_tof.o verdef_32_tom.o verdef_64_tof.o verdef_64_tom.o + HDRS_V = verdef.h verneed.h + + SRCS = $(SRCS1) $(SRCS2) $(SRCS3) $(SRCS4) $(SRCS5) $(SRCS64) $(SRCS_V) + OBJS = $(OBJS1) $(OBJS2) $(OBJS3) $(OBJS4) $(OBJS5) $(OBJS64) $(OBJS_V) + + # missing functions + LIBSRCS = memset.c + LIBOBJS = @LIBOBJS@ + + # public header files + HDRS = libelf.h nlist.h gelf.h + + # public header files (created by configure) + AUXHDRS = sys_elf.h + + # private header files + PRIVHDRS = byteswap.h errors.h ext_types.h private.h elf_repl.h $(HDRS_V) + + DISTFILES = $(SRCS) $(LIBSRCS) $(HDRS) $(PRIVHDRS) Makefile.in sys_elf.h.in + + all: objdirs libelf.a shared-$(DO_SHLIB) + + check: + + objdirs: + @for d in pic; do \ + test -d $$d || mkdir $$d || exit 1; \ + done + + shared-yes: $(SHLIB) + shared-no: + + libelf.a: $(OBJS) $(LIBOBJS) + @$(RM) $@ + $(AR) rcv $@ $(OBJS) $(LIBOBJS) + $(RANLIB) $@ + + $(SHLIB): $(OBJS) $(LIBOBJS) + @$(RM) $(SHLIB) + cd pic && \ + $(LINK_SHLIB) -o ../$(SHLIB) $(OBJS) $(LIBOBJS) $(DEPSHLIBS) + if test "$(SONAME)" = "$(SHLIB)"; then true; else \ + $(RM) $(SONAME) && $(LN_S) $(SHLIB) $(SONAME); \ + fi + if test "$(SHLINK)" = "$(SHLIB)"; then true; else \ + $(RM) $(SHLINK) && $(LN_S) $(SHLIB) $(SHLINK); \ + fi + + install: all installdirs install-data \ + install-shared-$(DO_SHLIB) install-compat-$(DO_COMPAT) + + installdirs: $(top_srcdir)/mkinstalldirs + dirs="$(installdirs)"; for dir in $$dirs; do \ + $(SHELL) $(top_srcdir)/mkinstalldirs $(instroot)$$dir; \ + done + + install-data: + $(INSTALL_DATA) libelf.a $(instroot)$(libdir) + -cd $(instroot)$(libdir) && $(RANLIB) libelf.a + files="$(HDRS) $(AUXHDRS) elf_repl.h"; for file in $$files; do \ + if test -r $$file; then \ + $(INSTALL_DATA) $$file $(instroot)$(includedir)/libelf; \ + else \ + $(INSTALL_DATA) $(srcdir)/$$file $(instroot)$(includedir)/libelf; \ + fi; \ + done + + uninstall: uninstall-data \ + uninstall-shared-$(DO_SHLIB) uninstall-compat-$(DO_COMPAT) + + uninstall-data: + $(RM) $(instroot)$(libdir)/libelf.a + $(RM) -r $(instroot)$(includedir)/libelf + + install-shared-yes: install-shared + install-shared-no: + install-shared: $(SHLIB) + $(INSTALL_SHLIB) $(SHLIB) $(instroot)$(libdir) + if test "$(SONAME)" = "$(SHLIB)"; then true; else \ + cd $(instroot)$(libdir) && $(RM) $(SONAME) && $(LN_S) $(SHLIB) $(SONAME); \ + fi + if test "$(SHLINK)" = "$(SHLIB)"; then true; else \ + cd $(instroot)$(libdir) && $(RM) $(SHLINK) && $(LN_S) $(SHLIB) $(SHLINK); \ + fi + + uninstall-shared-yes: uninstall-shared + uninstall-shared-no: + uninstall-shared: + cd $(instroot)$(libdir) && $(RM) $(SHLIB) $(SONAME) $(SHLINK) + + install-compat-yes: install-compat + install-compat-no: + install-compat: + files="$(HDRS)"; for file in $$files; do \ + if test -f $(instroot)$(includedir)/$$file; then true; else \ + echo "#include " > $(instroot)$(includedir)/$$file; \ + fi; \ + done + + uninstall-compat-yes: uninstall-compat + uninstall-compat-no: + uninstall-compat: + files="$(HDRS)"; for file in $$files; do \ + if grep "^#include \$$" $(instroot)$(includedir)/$$file >/dev/null 2>&1; then \ + $(RM) $(instroot)$(includedir)/$$file; \ + else true; fi; \ + done + + mostlyclean: + $(RM) *.o *.a pic/*.o $(SHLIB) $(SONAME) $(SHLINK) + $(RM) *~ core a.out errlist + + clean: mostlyclean + + distclean: clean + $(RM) stamp-h $(AUXHDRS) + $(RM) -r pic + $(RM) Makefile + + maintainer-clean: distclean + + # maintainer only + + MAINT = @MAINT@ + + distdir = $(PACKAGE)-$(VERSION) + distsubdir = $(topdir)/$(distdir)/$(subdir) + $(MAINT)dist: $(DISTFILES) + if test -d $(distsubdir); then true; else mkdir $(distsubdir); fi + files="$(DISTFILES)"; for file in $$files; do \ + ln $(srcdir)/$$file $(distsubdir) || \ + cp -p $(srcdir)/$$file $(distsubdir) || exit 1; \ + done + + # For the justification of the following Makefile rules, see node + # `Automatic Remaking' in GNU Autoconf documentation. + + $(MAINT)Makefile: Makefile.in $(topdir)/config.status + cd $(topdir) && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status + + $(MAINT)sys_elf.h: stamp-h + $(MAINT)stamp-h: sys_elf.h.in $(topdir)/config.status + cd $(topdir) && CONFIG_FILES= CONFIG_HEADERS=$(subdir)/sys_elf.h ./config.status + $(RM) stamp-h && echo timestamp > stamp-h + + # Tell versions [3.59,3.63) of GNU make not to export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. + .NOEXPORT: + + # dependencies + $(OBJS): private.h $(topdir)/config.h libelf.h gelf.h errors.h $(AUXHDRS) + 32.fsize.o: ext_types.h + 32.xlatetof.o: byteswap.h ext_types.h + 64.xlatetof.o: byteswap.h ext_types.h + getarsym.o: byteswap.h + memset.o: $(topdir)/config.h + nlist.o: nlist.h + swap64.o: byteswap.h + $(OBJS_V): byteswap.h ext_types.h $(HDRS_V) + verdef_32_tof.o: verdef.h verneed.h + verdef_32_tom.o: verdef.h verneed.h + verdef_64_tof.o: verdef.h verneed.h + verdef_64_tom.o: verdef.h verneed.h Index: llvm/lib/CodeGen/ELF/lib/assert.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/assert.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/assert.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,33 ---- + /* + assert.c - assert function for libelf. + Copyright (C) 1999 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: assert.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #include + + void + __elf_assert(const char *file, unsigned line, const char *cond) { + fprintf(stderr, "%s:%u: libelf assertion failure: %s\n", + file, line, cond); + abort(); + } Index: llvm/lib/CodeGen/ELF/lib/begin.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/begin.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/begin.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,431 ---- + /* + begin.c - implementation of the elf_begin(3) and elf_memory(3) functions. + Copyright (C) 1995 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: begin.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_AR_H + #include + #else /* HAVE_AR_H */ + + #define ARMAG "!\n" + #define SARMAG 8 + + struct ar_hdr { + char ar_name[16]; + char ar_date[12]; + char ar_uid[6]; + char ar_gid[6]; + char ar_mode[8]; + char ar_size[10]; + char ar_fmag[2]; + }; + + #define ARFMAG "`\n" + + #endif /* HAVE_AR_H */ + + static const Elf _elf_init = INIT_ELF; + static const char fmag[] = ARFMAG; + + static unsigned long + getnum(const char *str, size_t len, int base, int *err) { + unsigned long result = 0; + + while (len && *str == ' ') { + str++; len--; + } + while (len && *str >= '0' && (*str - '0') < base) { + result = base * result + *str++ - '0'; len--; + } + while (len && *str == ' ') { + str++; len--; + } + if (len) { + *err = len; + } + return result; + } + + static void + _elf_init_ar(Elf *elf) { + struct ar_hdr *hdr; + size_t offset; + size_t size; + int err = 0; + + elf->e_kind = ELF_K_AR; + elf->e_idlen = SARMAG; + elf->e_off = SARMAG; + + /* process special members */ + offset = SARMAG; + while (!elf->e_strtab && offset + sizeof(*hdr) <= elf->e_size) { + hdr = (struct ar_hdr*)(elf->e_data + offset); + if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) { + break; + } + if (hdr->ar_name[0] != '/') { + break; + } + size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err); + if (err || !size) { + break; + } + offset += sizeof(*hdr); + if (offset + size > elf->e_size) { + break; + } + if (hdr->ar_name[1] == '/' && hdr->ar_name[2] == ' ') { + elf->e_strtab = elf->e_data + offset; + elf->e_strlen = size; + break; + } + if (elf->e_symtab || hdr->ar_name[1] != ' ') { + break; + } + elf->e_symtab = elf->e_data + offset; + elf->e_symlen = size; + offset += size + (size & 1); + } + } + + static Elf_Arhdr* + _elf_arhdr(Elf *arf) { + struct ar_hdr *hdr; + Elf_Arhdr *arhdr; + size_t namelen; + size_t tmp; + char *name; + int err = 0; + + if (arf->e_off == arf->e_size) { + /* no error! */ + return NULL; + } + if (arf->e_off < 0 || arf->e_off > arf->e_size) { + seterr(ERROR_OUTSIDE); + return NULL; + } + if (arf->e_off + sizeof(*hdr) > arf->e_size) { + seterr(ERROR_TRUNC_ARHDR); + return NULL; + } + elf_assert(arf->e_data != NULL); + hdr = (struct ar_hdr*)(arf->e_data + arf->e_off); + if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) { + seterr(ERROR_ARFMAG); + return NULL; + } + + name = hdr->ar_name; + for (namelen = sizeof(hdr->ar_name); namelen > 0; namelen--) { + if (name[namelen - 1] != ' ') { + break; + } + } + if (name[0] == '/') { + if (name[1] >= '0' && name[1] <= '9') { + if (!arf->e_strtab) { + seterr(ERROR_ARSTRTAB); + return NULL; + } + tmp = getnum(&name[1], namelen - 1, 10, &err); + if (err) { + seterr(ERROR_ARSPECIAL); + return NULL; + } + if (tmp < 0 || tmp >= arf->e_strlen) { + seterr(ERROR_ARSTRTAB); + return NULL; + } + for (namelen = tmp; namelen < arf->e_strlen; namelen++) { + if (arf->e_strtab[namelen] == '/') { + break; + } + } + if (namelen == arf->e_strlen) { + seterr(ERROR_ARSTRTAB); + return NULL; + } + name = arf->e_strtab + tmp; + namelen -= tmp; + } + else if (namelen != 1 && !(namelen == 2 && name[1] == '/')) { + seterr(ERROR_ARSPECIAL); + return NULL; + } + } + else if (namelen > 0 && name[namelen - 1] == '/') { + namelen--; + } + /* XXX some broken software omits the trailing slash + else { + namelen = 0; + } + */ + + if (!(arhdr = (Elf_Arhdr*)malloc(sizeof(*arhdr) + + sizeof(hdr->ar_name) + namelen + 2))) { + seterr(ERROR_MEM_ARHDR); + return NULL; + } + + arhdr->ar_name = NULL; + arhdr->ar_rawname = (char*)(arhdr + 1); + arhdr->ar_date = getnum(hdr->ar_date, sizeof(hdr->ar_date), 10, &err); + arhdr->ar_uid = getnum(hdr->ar_uid, sizeof(hdr->ar_uid), 10, &err); + arhdr->ar_gid = getnum(hdr->ar_gid, sizeof(hdr->ar_gid), 10, &err); + arhdr->ar_mode = getnum(hdr->ar_mode, sizeof(hdr->ar_mode), 8, &err); + arhdr->ar_size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err); + if (err) { + free(arhdr); + seterr(ERROR_ARHDR); + return NULL; + } + if (arf->e_off + sizeof(struct ar_hdr) + arhdr->ar_size > arf->e_size) { + free(arhdr); + seterr(ERROR_TRUNC_MEMBER); + return NULL; + } + + memcpy(arhdr->ar_rawname, hdr->ar_name, sizeof(hdr->ar_name)); + arhdr->ar_rawname[sizeof(hdr->ar_name)] = '\0'; + + if (namelen) { + arhdr->ar_name = arhdr->ar_rawname + sizeof(hdr->ar_name) + 1; + memcpy(arhdr->ar_name, name, namelen); + arhdr->ar_name[namelen] = '\0'; + } + + return arhdr; + } + + static void + _elf_check_type(Elf *elf, size_t size) { + elf->e_idlen = size; + if (size >= EI_NIDENT && !memcmp(elf->e_data, ELFMAG, SELFMAG)) { + elf->e_kind = ELF_K_ELF; + elf->e_idlen = EI_NIDENT; + elf->e_class = elf->e_data[EI_CLASS]; + elf->e_encoding = elf->e_data[EI_DATA]; + elf->e_version = elf->e_data[EI_VERSION]; + } + else if (size >= SARMAG && !memcmp(elf->e_data, ARMAG, SARMAG)) { + _elf_init_ar(elf); + } + } + + Elf* + elf_begin(int fd, Elf_Cmd cmd, Elf *ref) { + Elf_Arhdr *arhdr = NULL; + size_t size = 0; + off_t off; + Elf *elf; + + elf_assert(_elf_init.e_magic == ELF_MAGIC); + if (_elf_version == EV_NONE) { + seterr(ERROR_VERSION_UNSET); + return NULL; + } + else if (cmd == ELF_C_NULL) { + return NULL; + } + else if (cmd == ELF_C_WRITE) { + ref = NULL; + } + else if (cmd != ELF_C_READ && cmd != ELF_C_RDWR) { + seterr(ERROR_INVALID_CMD); + return NULL; + } + else if (ref) { + elf_assert(ref->e_magic == ELF_MAGIC); + if (!ref->e_readable || (cmd == ELF_C_RDWR && !ref->e_writable)) { + seterr(ERROR_CMDMISMATCH); + return NULL; + } + if (ref->e_kind != ELF_K_AR) { + ref->e_count++; + return ref; + } + if (cmd == ELF_C_RDWR) { + seterr(ERROR_MEMBERWRITE); + return NULL; + } + if (ref->e_memory) { + fd = ref->e_fd; + } + else if (fd != ref->e_fd) { + seterr(ERROR_FDMISMATCH); + return NULL; + } + if (!(arhdr = _elf_arhdr(ref))) { + return NULL; + } + size = arhdr->ar_size; + } + else if ((off = lseek(fd, (off_t)0, SEEK_END)) == (off_t)-1 || (size = off) != off) { + seterr(ERROR_IO_GETSIZE); + return NULL; + } + + if (!(elf = (Elf*)malloc(sizeof(Elf)))) { + seterr(ERROR_MEM_ELF); + return NULL; + } + *elf = _elf_init; + elf->e_fd = fd; + elf->e_parent = ref; + elf->e_size = elf->e_dsize = size; + + if (cmd != ELF_C_READ) { + elf->e_writable = 1; + } + if (cmd != ELF_C_WRITE) { + elf->e_readable = 1; + } + else { + return elf; + } + + if (ref) { + size_t offset = ref->e_off + sizeof(struct ar_hdr); + Elf *xelf; + + elf_assert(arhdr); + elf->e_arhdr = arhdr; + elf->e_base = ref->e_base + offset; + /* + * Share the archive's memory image. To avoid + * multiple independent elf descriptors if the + * same member is requested twice, scan the list + * of open members for duplicates. + * + * I don't know how SVR4 handles this case. Don't rely on it. + */ + for (xelf = ref->e_members; xelf; xelf = xelf->e_link) { + elf_assert(xelf->e_parent == ref); + if (xelf->e_base == elf->e_base) { + free(arhdr); + free(elf); + xelf->e_count++; + return xelf; + } + } + if (size == 0) { + elf->e_data = NULL; + } + else if (ref->e_data == ref->e_rawdata) { + elf_assert(!ref->e_cooked); + /* + * archive is frozen - freeze member, too + */ + elf->e_data = elf->e_rawdata = ref->e_data + offset; + } + else { + elf_assert(!ref->e_memory); + elf->e_data = ref->e_data + offset; + /* + * The member's memory image may have been modified if + * the member has been processed before. Since we need the + * original image, we have to re-read the archive file. + * Will fail if the archive's file descriptor is disabled. + */ + if (!ref->e_cooked) { + ref->e_cooked = 1; + } + else if (!_elf_read(ref, elf->e_data, offset, size)) { + free(arhdr); + free(elf); + return NULL; + } + } + elf->e_next = offset + size + (size & 1); + elf->e_disabled = ref->e_disabled; + elf->e_memory = ref->e_memory; + /* parent/child linking */ + elf->e_link = ref->e_members; + ref->e_members = elf; + ref->e_count++; + /* Slowaris compatibility - do not rely on this! */ + ref->e_off = elf->e_next; + } + else if (size) { + #if HAVE_MMAP + /* + * Using mmap on writable files will interfere with elf_update + */ + if (!elf->e_writable && (elf->e_data = _elf_mmap(elf))) { + elf->e_unmap_data = 1; + } + else + #endif /* HAVE_MMAP */ + if (!(elf->e_data = _elf_read(elf, NULL, 0, size))) { + free(elf); + return NULL; + } + } + + _elf_check_type(elf, size); + return elf; + } + + Elf* + elf_memory(char *image, size_t size) { + Elf *elf; + + elf_assert(_elf_init.e_magic == ELF_MAGIC); + if (_elf_version == EV_NONE) { + seterr(ERROR_VERSION_UNSET); + return NULL; + } + else if (size == 0 || image == NULL) { + /* TODO: set error code? */ + return NULL; + } + + if (!(elf = (Elf*)malloc(sizeof(Elf)))) { + seterr(ERROR_MEM_ELF); + return NULL; + } + *elf = _elf_init; + elf->e_size = elf->e_dsize = size; + elf->e_data = elf->e_rawdata = image; + elf->e_readable = 1; + elf->e_disabled = 1; + elf->e_memory = 1; + + _elf_check_type(elf, size); + return elf; + } + + #if __LIBELF64 + + int + gelf_getclass(Elf *elf) { + if (elf && elf->e_kind == ELF_K_ELF && valid_class(elf->e_class)) { + return elf->e_class; + } + return ELFCLASSNONE; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/byteswap.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/byteswap.h:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/byteswap.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,95 ---- + /* + byteswap.h - functions and macros for byte swapping. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: byteswap.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _BYTESWAP_H + #define _BYTESWAP_H + + #define lu(from,i,s) (((__libelf_u32_t)((unsigned char*)(from))[i])<<(s)) + #define li(from,i,s) (((__libelf_i32_t)(( signed char*)(from))[i])<<(s)) + + #define __load_u16L(from) ((__libelf_u32_t) \ + (lu(from,1,8) | lu(from,0,0))) + #define __load_u16M(from) ((__libelf_u32_t) \ + (lu(from,0,8) | lu(from,1,0))) + #define __load_i16L(from) ((__libelf_i32_t) \ + (li(from,1,8) | lu(from,0,0))) + #define __load_i16M(from) ((__libelf_i32_t) \ + (li(from,0,8) | lu(from,1,0))) + + #define __load_u32L(from) ((__libelf_u32_t) \ + (lu(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0))) + #define __load_u32M(from) ((__libelf_u32_t) \ + (lu(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0))) + #define __load_i32L(from) ((__libelf_i32_t) \ + (li(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0))) + #define __load_i32M(from) ((__libelf_i32_t) \ + (li(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0))) + + #define su(to,i,v,s) (((char*)(to))[i]=((__libelf_u32_t)(v)>>(s))) + #define si(to,i,v,s) (((char*)(to))[i]=((__libelf_i32_t)(v)>>(s))) + + #define __store_u16L(to,v) \ + (su(to,1,v,8), su(to,0,v,0)) + #define __store_u16M(to,v) \ + (su(to,0,v,8), su(to,1,v,0)) + #define __store_i16L(to,v) \ + (si(to,1,v,8), si(to,0,v,0)) + #define __store_i16M(to,v) \ + (si(to,0,v,8), si(to,1,v,0)) + + #define __store_u32L(to,v) \ + (su(to,3,v,24), su(to,2,v,16), su(to,1,v,8), su(to,0,v,0)) + #define __store_u32M(to,v) \ + (su(to,0,v,24), su(to,1,v,16), su(to,2,v,8), su(to,3,v,0)) + #define __store_i32L(to,v) \ + (si(to,3,v,24), si(to,2,v,16), si(to,1,v,8), si(to,0,v,0)) + #define __store_i32M(to,v) \ + (si(to,0,v,24), si(to,1,v,16), si(to,2,v,8), si(to,3,v,0)) + + #if __LIBELF64 + + /* + * conversion functions from swap64.c + */ + extern __libelf_u64_t _elf_load_u64L(const unsigned char *from); + extern __libelf_u64_t _elf_load_u64M(const unsigned char *from); + extern __libelf_i64_t _elf_load_i64L(const unsigned char *from); + extern __libelf_i64_t _elf_load_i64M(const unsigned char *from); + extern void _elf_store_u64L(unsigned char *to, __libelf_u64_t v); + extern void _elf_store_u64M(unsigned char *to, __libelf_u64_t v); + extern void _elf_store_i64L(unsigned char *to, __libelf_u64_t v); + extern void _elf_store_i64M(unsigned char *to, __libelf_u64_t v); + + /* + * aliases for existing conversion code + */ + #define __load_u64L _elf_load_u64L + #define __load_u64M _elf_load_u64M + #define __load_i64L _elf_load_i64L + #define __load_i64M _elf_load_i64M + #define __store_u64L _elf_store_u64L + #define __store_u64M _elf_store_u64M + #define __store_i64L _elf_store_i64L + #define __store_i64M _elf_store_i64M + + #endif /* __LIBELF64 */ + + #endif /* _BYTESWAP_H */ Index: llvm/lib/CodeGen/ELF/lib/checksum.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/checksum.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/checksum.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,178 ---- + /* + checksum.c - implementation of the elf{32,64}_checksum(3) functions. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: checksum.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + /* + * Compatibility note: + * + * The algorithm used in {elf32,elf64,gelf}_checksum() does not seem to + * be documented. I hope I got it right. My implementation does the + * following: + * + * - skip sections that do not have the SHF_ALLOC flag set + * - skip sections of type SHT_NULL, SHT_NOBITS, SHT_DYNSYM and + * SHT_DYNAMIC + * - add all data bytes from the remaining sections, modulo 2**32 + * - add upper and lower half of the result + * - subtract 0xffff if the result is > 0xffff + * - if any error occurs, return 0L + */ + + static int + skip_section(Elf_Scn *scn, unsigned cls) { + if (cls == ELFCLASS32) { + Elf32_Shdr *shdr = &scn->s_shdr32; + + if (!(shdr->sh_flags & SHF_ALLOC)) { + return 1; + } + switch (shdr->sh_type) { + case SHT_NULL: + case SHT_NOBITS: + /* Solaris seems to ignore these, too */ + case SHT_DYNSYM: + case SHT_DYNAMIC: + return 1; + } + } + #if __LIBELF64 + else if (cls == ELFCLASS64) { + Elf64_Shdr *shdr = &scn->s_shdr64; + + if (!(shdr->sh_flags & SHF_ALLOC)) { + return 1; + } + switch (shdr->sh_type) { + case SHT_NULL: + case SHT_NOBITS: + /* Solaris seems to ignore these, too */ + case SHT_DYNSYM: + case SHT_DYNAMIC: + return 1; + } + } + #endif /* __LIBELF64 */ + else { + seterr(ERROR_UNIMPLEMENTED); + } + return 0; + } + + static long + add_bytes(unsigned char *ptr, size_t len) { + long csum = 0; + + while (len--) { + csum += *ptr++; + } + return csum; + } + + static long + _elf_csum(Elf *elf) { + long csum = 0; + Elf_Data *data; + Elf_Scn *scn; + + if (!elf->e_ehdr && !_elf_cook(elf)) { + /* propagate errors from _elf_cook */ + return 0L; + } + seterr(0); + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + if (scn->s_index == SHN_UNDEF || skip_section(scn, elf->e_class)) { + continue; + } + data = NULL; + while ((data = elf_getdata(scn, data))) { + if (data->d_size) { + if (data->d_buf == NULL) { + seterr(ERROR_NULLBUF); + return 0L; + } + csum += add_bytes(data->d_buf, data->d_size); + } + } + } + if (_elf_errno) { + return 0L; + } + csum = (csum & 0xffff) + ((csum >> 16) & 0xffff); + if (csum > 0xffff) { + csum -= 0xffff; + } + return csum; + } + + long + elf32_checksum(Elf *elf) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class != ELFCLASS32) { + seterr(ERROR_CLASSMISMATCH); + } + else { + return _elf_csum(elf); + } + } + return 0L; + } + + #if __LIBELF64 + + long + elf64_checksum(Elf *elf) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class != ELFCLASS64) { + seterr(ERROR_CLASSMISMATCH); + } + else { + return _elf_csum(elf); + } + } + return 0L; + } + + long + gelf_checksum(Elf *elf) { + if (elf) { + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (!valid_class(elf->e_class)) { + seterr(ERROR_UNKNOWN_CLASS); + } + else { + return _elf_csum(elf); + } + } + return 0L; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/cntl.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/cntl.c:1.1 *** /dev/null Wed Jun 22 01:36:09 2005 --- llvm/lib/CodeGen/ELF/lib/cntl.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,71 ---- + /* + cntl.c - implementation of the elf_cntl(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: cntl.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + int + elf_cntl(Elf *elf, Elf_Cmd cmd) { + Elf_Scn *scn; + Elf *child; + + if (!elf) { + return -1; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (cmd == ELF_C_FDREAD) { + if (!elf->e_readable) { + seterr(ERROR_WRONLY); + return -1; + } + } + else if (cmd != ELF_C_FDDONE) { + seterr(ERROR_INVALID_CMD); + return -1; + } + if (elf->e_disabled) { + return 0; + } + if (elf->e_kind == ELF_K_AR) { + for (child = elf->e_members; child; child = child->e_link) { + elf_assert(elf == child->e_parent); + if (elf_cntl(child, cmd)) { + return -1; + } + } + } + else if (elf->e_kind == ELF_K_ELF && cmd == ELF_C_FDREAD) { + if (!elf->e_ehdr && !_elf_cook(elf)) { + return -1; + } + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) { + continue; + } + else if (!elf_getdata(scn, NULL)) { + return -1; + } + } + } + elf->e_disabled = 1; + return 0; + } Index: llvm/lib/CodeGen/ELF/lib/cook.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/cook.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/cook.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,457 ---- + /* + cook.c - read and translate ELF files. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: cook.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + const Elf_Scn _elf_scn_init = INIT_SCN; + const Scn_Data _elf_data_init = INIT_DATA; + + Elf_Type + _elf_scn_type(unsigned t) { + switch (t) { + case SHT_DYNAMIC: return ELF_T_DYN; + case SHT_DYNSYM: return ELF_T_SYM; + case SHT_HASH: return ELF_T_WORD; + case SHT_REL: return ELF_T_REL; + case SHT_RELA: return ELF_T_RELA; + case SHT_SYMTAB: return ELF_T_SYM; + case SHT_SYMTAB_SHNDX: return ELF_T_WORD; /* XXX: really? */ + #if __LIBELF_SYMBOL_VERSIONS + #if __LIBELF_SUN_SYMBOL_VERSIONS + case SHT_SUNW_verdef: return ELF_T_VDEF; + case SHT_SUNW_verneed: return ELF_T_VNEED; + case SHT_SUNW_versym: return ELF_T_HALF; + #else /* __LIBELF_SUN_SYMBOL_VERSIONS */ + case SHT_GNU_verdef: return ELF_T_VDEF; + case SHT_GNU_verneed: return ELF_T_VNEED; + case SHT_GNU_versym: return ELF_T_HALF; + #endif /* __LIBELF_SUN_SYMBOL_VERSIONS */ + #endif /* __LIBELF_SYMBOL_VERSIONS */ + } + return ELF_T_BYTE; + } + + /* + * Check for overflow on 32-bit systems + */ + #define overflow(a,b,t) (sizeof(a) < sizeof(t) && (t)(a) != (b)) + + #define truncerr(t) ((t)==ELF_T_EHDR?ERROR_TRUNC_EHDR: \ + ((t)==ELF_T_PHDR?ERROR_TRUNC_PHDR: \ + ERROR_INTERNAL)) + #define memerr(t) ((t)==ELF_T_EHDR?ERROR_MEM_EHDR: \ + ((t)==ELF_T_PHDR?ERROR_MEM_PHDR: \ + ERROR_INTERNAL)) + + Elf_Data* + _elf_xlatetom(const Elf *elf, Elf_Data *dst, const Elf_Data *src) { + if (elf->e_class == ELFCLASS32) { + return elf32_xlatetom(dst, src, elf->e_encoding); + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + return elf64_xlatetom(dst, src, elf->e_encoding); + } + #endif /* __LIBELF64 */ + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + + static char* + _elf_item(Elf *elf, Elf_Type type, size_t n, size_t off, int *flag) { + Elf_Data src, dst; + + *flag = 0; + elf_assert(n); + elf_assert(valid_type(type)); + if (off < 0 || off > elf->e_size) { + seterr(ERROR_OUTSIDE); + return NULL; + } + + src.d_type = type; + src.d_version = elf->e_version; + src.d_size = n * _fsize(elf->e_class, src.d_version, type); + elf_assert(src.d_size); + if ((elf->e_size - off) < src.d_size) { + seterr(truncerr(type)); + return NULL; + } + + dst.d_version = _elf_version; + dst.d_size = n * _msize(elf->e_class, dst.d_version, type); + elf_assert(dst.d_size); + + elf_assert(elf->e_data); + if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) { + dst.d_buf = elf->e_data + off; + } + else if (!(dst.d_buf = malloc(dst.d_size))) { + seterr(memerr(type)); + return NULL; + } + else { + *flag = 1; + } + + if (elf->e_rawdata) { + src.d_buf = elf->e_rawdata + off; + } + else { + src.d_buf = elf->e_data + off; + } + + if (_elf_xlatetom(elf, &dst, &src)) { + if (!*flag) { + elf->e_cooked = 1; + } + return (char*)dst.d_buf; + } + + if (*flag) { + free(dst.d_buf); + *flag = 0; + } + return NULL; + } + + #undef truncerr + #undef memerr + + static int + _elf_cook_file(Elf *elf) { + size_t num, off, align_addr; + int flag; + + elf->e_ehdr = _elf_item(elf, ELF_T_EHDR, 1, 0, &flag); + if (!elf->e_ehdr) { + return 0; + } + if (flag) { + elf->e_free_ehdr = 1; + } + align_addr = _fsize(elf->e_class, elf->e_version, ELF_T_ADDR); + elf_assert(align_addr); + if (elf->e_class == ELFCLASS32) { + num = ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum; + off = ((Elf32_Ehdr*)elf->e_ehdr)->e_phoff; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + num = ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum; + off = ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff; + /* + * Check for overflow on 32-bit systems + */ + if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff, Elf64_Off)) { + seterr(ERROR_OUTSIDE); + return 0; + } + } + #endif /* __LIBELF64 */ + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + if (num && off) { + if (off % align_addr) { + seterr(ERROR_ALIGN_PHDR); + return 0; + } + elf->e_phdr = _elf_item(elf, ELF_T_PHDR, num, off, &flag); + if (!elf->e_phdr) { + return 0; + } + if (flag) { + elf->e_free_phdr = 1; + } + elf->e_phnum = num; + } + if (elf->e_class == ELFCLASS32) { + num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum; + off = ((Elf32_Ehdr*)elf->e_ehdr)->e_shoff; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum; + off = ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff; + /* + * Check for overflow on 32-bit systems + */ + if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff, Elf64_Off)) { + seterr(ERROR_OUTSIDE); + return 0; + } + } + #endif /* __LIBELF64 */ + /* we already had this + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + */ + if (off) { + struct tmp { + Elf_Scn scn; + Scn_Data data; + } *head; + Elf_Data src, dst; + Elf_Scn *scn; + Scn_Data *sd; + unsigned i; + + if (off % align_addr) { + seterr(ERROR_ALIGN_SHDR); + return 0; + } + if (off < 0 || off > elf->e_size) { + seterr(ERROR_OUTSIDE); + return 0; + } + + src.d_type = ELF_T_SHDR; + src.d_version = elf->e_version; + src.d_size = _fsize(elf->e_class, src.d_version, ELF_T_SHDR); + elf_assert(src.d_size); + dst.d_version = EV_CURRENT; + + if (num == 0) { + union { + Elf32_Shdr sh32; + Elf64_Shdr sh64; + } u; + + /* + * Overflow in ehdr->e_shnum. + * Get real value from first SHDR. + */ + if (elf->e_size - off < src.d_size) { + seterr(ERROR_TRUNC_SHDR); + return 0; + } + if (elf->e_rawdata) { + src.d_buf = elf->e_rawdata + off; + } + else { + src.d_buf = elf->e_data + off; + } + dst.d_buf = &u; + dst.d_size = sizeof(u); + if (!(_elf_xlatetom(elf, &dst, &src))) { + return 0; + } + elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR)); + elf_assert(dst.d_type == ELF_T_SHDR); + if (elf->e_class == ELFCLASS32) { + num = u.sh32.sh_size; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + num = u.sh64.sh_size; + /* + * Check for overflow on 32-bit systems + */ + if (overflow(num, u.sh64.sh_size, Elf64_Xword)) { + seterr(ERROR_OUTSIDE); + return 0; + } + } + #endif /* __LIBELF64 */ + if (num < SHN_LORESERVE) { + /* XXX: shall we tolerate this? */ + seterr(ERROR_EHDR_SHNUM); + return 0; + } + } + + if ((elf->e_size - off) / src.d_size < num) { + seterr(ERROR_TRUNC_SHDR); + return 0; + } + + if (!(head = (struct tmp*)malloc(num * sizeof(struct tmp)))) { + seterr(ERROR_MEM_SCN); + return 0; + } + for (scn = NULL, i = num; i-- > 0; ) { + head[i].scn = _elf_scn_init; + head[i].data = _elf_data_init; + head[i].scn.s_link = scn; + if (!scn) { + elf->e_scn_n = &head[i].scn; + } + scn = &head[i].scn; + sd = &head[i].data; + + if (elf->e_rawdata) { + src.d_buf = elf->e_rawdata + off + i * src.d_size; + } + else { + src.d_buf = elf->e_data + off + i * src.d_size; + } + dst.d_buf = &scn->s_uhdr; + dst.d_size = sizeof(scn->s_uhdr); + if (!(_elf_xlatetom(elf, &dst, &src))) { + elf->e_scn_n = NULL; + free(head); + return 0; + } + elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR)); + elf_assert(dst.d_type == ELF_T_SHDR); + + scn->s_elf = elf; + scn->s_index = i; + scn->s_data_1 = sd; + scn->s_data_n = sd; + + sd->sd_scn = scn; + + if (elf->e_class == ELFCLASS32) { + Elf32_Shdr *shdr = &scn->s_shdr32; + + scn->s_type = shdr->sh_type; + scn->s_size = shdr->sh_size; + scn->s_offset = shdr->sh_offset; + sd->sd_data.d_align = shdr->sh_addralign; + sd->sd_data.d_type = _elf_scn_type(scn->s_type); + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + Elf64_Shdr *shdr = &scn->s_shdr64; + + scn->s_type = shdr->sh_type; + scn->s_size = shdr->sh_size; + scn->s_offset = shdr->sh_offset; + sd->sd_data.d_align = shdr->sh_addralign; + /* + * Check for overflow on 32-bit systems + */ + if (overflow(scn->s_size, shdr->sh_size, Elf64_Xword) + || overflow(scn->s_offset, shdr->sh_offset, Elf64_Off) + || overflow(sd->sd_data.d_align, shdr->sh_addralign, Elf64_Xword)) { + seterr(ERROR_OUTSIDE); + return 0; + } + sd->sd_data.d_type = _elf_scn_type(scn->s_type); + /* + * QUIRKS MODE: + * + * Some 64-bit architectures use 64-bit entries in the + * .hash section. This violates the ELF standard, and + * should be fixed. It's mostly harmless as long as the + * binary and the machine running your program have the + * same byte order, but you're in trouble if they don't, + * and if the entry size is wrong. + * + * As a workaround, I let libelf guess the right size + * for the binary. This relies pretty much on the fact + * that the binary provides correct data in the section + * headers. If it doesn't, it's probably broken anyway. + * Therefore, libelf uses a standard conforming value + * when it's not absolutely sure. + */ + if (scn->s_type == SHT_HASH) { + int override = 0; + + /* + * sh_entsize must reflect the entry size + */ + if (shdr->sh_entsize == ELF64_FSZ_ADDR) { + override++; + } + /* + * sh_size must be a multiple of sh_entsize + */ + if (shdr->sh_size % ELF64_FSZ_ADDR == 0) { + override++; + } + /* + * There must be room for at least 2 entries + */ + if (shdr->sh_size >= 2 * ELF64_FSZ_ADDR) { + override++; + } + /* + * sh_addralign must be correctly set + */ + if (shdr->sh_addralign == ELF64_FSZ_ADDR) { + override++; + } + /* + * The section must be properly aligned + */ + if (shdr->sh_offset % ELF64_FSZ_ADDR == 0) { + override++; + } + /* XXX: also look at the data? */ + /* + * Make a conservative decision... + */ + if (override >= 5) { + sd->sd_data.d_type = ELF_T_ADDR; + } + } + /* + * END QUIRKS MODE. + */ + } + #endif /* __LIBELF64 */ + /* we already had this + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + */ + + sd->sd_data.d_size = scn->s_size; + sd->sd_data.d_version = _elf_version; + } + elf_assert(scn == &head[0].scn); + elf->e_scn_1 = &head[0].scn; + head[0].scn.s_freeme = 1; + } + return 1; + } + + int + _elf_cook(Elf *elf) { + elf_assert(_elf_scn_init.s_magic == SCN_MAGIC); + elf_assert(_elf_data_init.sd_magic == DATA_MAGIC); + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + elf_assert(elf->e_kind == ELF_K_ELF); + elf_assert(!elf->e_ehdr); + if (!valid_version(elf->e_version)) { + seterr(ERROR_UNKNOWN_VERSION); + } + else if (!valid_encoding(elf->e_encoding)) { + seterr(ERROR_UNKNOWN_ENCODING); + } + else if (valid_class(elf->e_class)) { + return _elf_cook_file(elf); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + return 0; + } Index: llvm/lib/CodeGen/ELF/lib/data.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/data.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/data.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,28 ---- + /* + data.c - libelf internal variables. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: data.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + unsigned _elf_version = EV_NONE; + int _elf_errno = 0; + int _elf_fill = 0; Index: llvm/lib/CodeGen/ELF/lib/elf_repl.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/elf_repl.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/elf_repl.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,917 ---- + /* + elf_repl.h - public header file for systems that lack it. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: elf_repl.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + /* + * NEVER INCLUDE THIS FILE DIRECTLY - USE INSTEAD! + */ + + #ifndef _ELF_REPL_H + #define _ELF_REPL_H + + #ifdef __cplusplus + extern "C" { + #endif /* __cplusplus */ + + /* + * Scalar data types + */ + typedef __libelf_u32_t Elf32_Addr; + typedef __libelf_u16_t Elf32_Half; + typedef __libelf_u32_t Elf32_Off; + typedef __libelf_i32_t Elf32_Sword; + typedef __libelf_u32_t Elf32_Word; + + #define ELF32_FSZ_ADDR 4 + #define ELF32_FSZ_HALF 2 + #define ELF32_FSZ_OFF 4 + #define ELF32_FSZ_SWORD 4 + #define ELF32_FSZ_WORD 4 + + #if __LIBELF64 + + typedef __libelf_u64_t Elf64_Addr; + typedef __libelf_u16_t Elf64_Half; + typedef __libelf_u64_t Elf64_Off; + typedef __libelf_i32_t Elf64_Sword; + typedef __libelf_u32_t Elf64_Word; + typedef __libelf_i64_t Elf64_Sxword; + typedef __libelf_u64_t Elf64_Xword; + + #define ELF64_FSZ_ADDR 8 + #define ELF64_FSZ_HALF 2 + #define ELF64_FSZ_OFF 8 + #define ELF64_FSZ_SWORD 4 + #define ELF64_FSZ_WORD 4 + #define ELF64_FSZ_SXWORD 8 + #define ELF64_FSZ_XWORD 8 + + /* + * Blame Sun for this... + */ + typedef __libelf_u64_t Elf64_Lword; + typedef __libelf_u64_t Elf32_Lword; + + #endif /* __LIBELF64 */ + + /* + * ELF header + */ + #define EI_NIDENT 16 + + typedef struct { + unsigned char e_ident[EI_NIDENT]; + Elf32_Half e_type; + Elf32_Half e_machine; + Elf32_Word e_version; + Elf32_Addr e_entry; + Elf32_Off e_phoff; + Elf32_Off e_shoff; + Elf32_Word e_flags; + Elf32_Half e_ehsize; + Elf32_Half e_phentsize; + Elf32_Half e_phnum; + Elf32_Half e_shentsize; + Elf32_Half e_shnum; + Elf32_Half e_shstrndx; + } Elf32_Ehdr; + + #if __LIBELF64 + typedef struct { + unsigned char e_ident[EI_NIDENT]; + Elf64_Half e_type; + Elf64_Half e_machine; + Elf64_Word e_version; + Elf64_Addr e_entry; + Elf64_Off e_phoff; + Elf64_Off e_shoff; + Elf64_Word e_flags; + Elf64_Half e_ehsize; + Elf64_Half e_phentsize; + Elf64_Half e_phnum; + Elf64_Half e_shentsize; + Elf64_Half e_shnum; + Elf64_Half e_shstrndx; + } Elf64_Ehdr; + #endif /* __LIBELF64 */ + + /* + * e_ident + */ + #define EI_MAG0 0 + #define EI_MAG1 1 + #define EI_MAG2 2 + #define EI_MAG3 3 + #define EI_CLASS 4 + #define EI_DATA 5 + #define EI_VERSION 6 + #define EI_OSABI 7 + #define EI_ABIVERSION 8 + #define EI_PAD 9 + + #define ELFMAG0 0x7f + #define ELFMAG1 'E' + #define ELFMAG2 'L' + #define ELFMAG3 'F' + #define ELFMAG "\177ELF" + #define SELFMAG 4 + + /* + * e_ident[EI_CLASS] + */ + #define ELFCLASSNONE 0 + #define ELFCLASS32 1 + #define ELFCLASS64 2 + #define ELFCLASSNUM 3 + + /* + * e_ident[EI_DATA] + */ + #define ELFDATANONE 0 + #define ELFDATA2LSB 1 + #define ELFDATA2MSB 2 + #define ELFDATANUM 3 + + /* + * e_ident[EI_OSABI] + */ + #define ELFOSABI_NONE 0 /* No extensions or unspecified */ + #define ELFOSABI_SYSV ELFOSABI_NONE + #define ELFOSABI_HPUX 1 /* Hewlett-Packard HP-UX */ + #define ELFOSABI_NETBSD 2 /* NetBSD */ + #define ELFOSABI_LINUX 3 /* Linux */ + #define ELFOSABI_SOLARIS 6 /* Sun Solaris */ + #define ELFOSABI_AIX 7 /* AIX */ + #define ELFOSABI_IRIX 8 /* IRIX */ + #define ELFOSABI_FREEBSD 9 /* FreeBSD */ + #define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX */ + #define ELFOSABI_MODESTO 11 /* Novell Modesto */ + #define ELFOSABI_OPENBSD 12 /* Open BSD */ + #define ELFOSABI_OPENVMS 13 /* Open VMS */ + #define ELFOSABI_NSK 14 /* Hewlett-Packard Non-Stop Kernel */ + /* these are probably obsolete: */ + #define ELFOSABI_ARM 97 /* ARM */ + #define ELFOSABI_STANDALONE 255 /* standalone (embedded) application */ + + + /* + * e_type + */ + #define ET_NONE 0 + #define ET_REL 1 + #define ET_EXEC 2 + #define ET_DYN 3 + #define ET_CORE 4 + #define ET_NUM 5 + #define ET_LOOS 0xfe00 + #define ET_HIOS 0xfeff + #define ET_LOPROC 0xff00 + #define ET_HIPROC 0xffff + + /* + * e_machine + */ + #define EM_NONE 0 /* No machine */ + #define EM_M32 1 /* AT&T WE 32100 */ + #define EM_SPARC 2 /* SPARC */ + #define EM_386 3 /* Intel 80386 */ + #define EM_68K 4 /* Motorola 68000 */ + #define EM_88K 5 /* Motorola 88000 */ + #define EM_486 6 /* Intel i486 (DO NOT USE THIS ONE) */ + #define EM_860 7 /* Intel 80860 */ + #define EM_MIPS 8 /* MIPS I Architecture */ + #define EM_S370 9 /* IBM System/370 Processor */ + #define EM_MIPS_RS3_LE 10 /* MIPS RS3000 Little-endian */ + #define EM_SPARC64 11 /* SPARC 64-bit */ + #define EM_PARISC 15 /* Hewlett-Packard PA-RISC */ + #define EM_VPP500 17 /* Fujitsu VPP500 */ + #define EM_SPARC32PLUS 18 /* Enhanced instruction set SPARC */ + #define EM_960 19 /* Intel 80960 */ + #define EM_PPC 20 /* PowerPC */ + #define EM_PPC64 21 /* 64-bit PowerPC */ + #define EM_S390 22 /* IBM System/390 Processor */ + #define EM_V800 36 /* NEC V800 */ + #define EM_FR20 37 /* Fujitsu FR20 */ + #define EM_RH32 38 /* TRW RH-32 */ + #define EM_RCE 39 /* Motorola RCE */ + #define EM_ARM 40 /* Advanced RISC Machines ARM */ + #define EM_ALPHA 41 /* Digital Alpha */ + #define EM_SH 42 /* Hitachi SH */ + #define EM_SPARCV9 43 /* SPARC Version 9 */ + #define EM_TRICORE 44 /* Siemens TriCore embedded processor */ + #define EM_ARC 45 /* Argonaut RISC Core, Argonaut Technologies Inc. */ + #define EM_H8_300 46 /* Hitachi H8/300 */ + #define EM_H8_300H 47 /* Hitachi H8/300H */ + #define EM_H8S 48 /* Hitachi H8S */ + #define EM_H8_500 49 /* Hitachi H8/500 */ + #define EM_IA_64 50 /* Intel IA-64 processor architecture */ + #define EM_MIPS_X 51 /* Stanford MIPS-X */ + #define EM_COLDFIRE 52 /* Motorola ColdFire */ + #define EM_68HC12 53 /* Motorola M68HC12 */ + #define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator */ + #define EM_PCP 55 /* Siemens PCP */ + #define EM_NCPU 56 /* Sony nCPU embedded RISC processor */ + #define EM_NDR1 57 /* Denso NDR1 microprocessor */ + #define EM_STARCORE 58 /* Motorola Star*Core processor */ + #define EM_ME16 59 /* Toyota ME16 processor */ + #define EM_ST100 60 /* STMicroelectronics ST100 processor */ + #define EM_TINYJ 61 /* Advanced Logic Corp. TinyJ embedded processor family */ + #define EM_X86_64 62 /* AMD x86-64 architecture */ + #define EM_PDSP 63 /* Sony DSP Processor */ + #define EM_FX66 66 /* Siemens FX66 microcontroller */ + #define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 bit microcontroller */ + #define EM_ST7 68 /* STMicroelectronics ST7 8-bit microcontroller */ + #define EM_68HC16 69 /* Motorola MC68HC16 Microcontroller */ + #define EM_68HC11 70 /* Motorola MC68HC11 Microcontroller */ + #define EM_68HC08 71 /* Motorola MC68HC08 Microcontroller */ + #define EM_68HC05 72 /* Motorola MC68HC05 Microcontroller */ + #define EM_SVX 73 /* Silicon Graphics SVx */ + #define EM_ST19 74 /* STMicroelectronics ST19 8-bit microcontroller */ + #define EM_VAX 75 /* Digital VAX */ + #define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */ + #define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */ + #define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */ + #define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */ + #define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */ + #define EM_HUANY 81 /* Harvard University machine-independent object files */ + #define EM_PRISM 82 /* SiTera Prism */ + #define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */ + #define EM_FR30 84 /* Fujitsu FR30 */ + #define EM_D10V 85 /* Mitsubishi D10V */ + #define EM_D30V 86 /* Mitsubishi D30V */ + #define EM_V850 87 /* NEC v850 */ + #define EM_M32R 88 /* Mitsubishi M32R */ + #define EM_MN10300 89 /* Matsushita MN10300 */ + #define EM_MN10200 90 /* Matsushita MN10200 */ + #define EM_PJ 91 /* picoJava */ + #define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */ + #define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */ + #define EM_XTENSA 94 /* Tensilica Xtensa Architecture */ + #define EM_VIDEOCORE 95 /* Alphamosaic VideoCore processor */ + #define EM_TMM_GPP 96 /* Thompson Multimedia General Purpose Processor */ + #define EM_NS32K 97 /* National Semiconductor 32000 series */ + #define EM_TPC 98 /* Tenor Network TPC processor */ + #define EM_SNP1K 99 /* Trebia SNP 1000 processor */ + #define EM_ST200 100 /* STMicroelectronics (www.st.com) ST200 microcontroller */ + #define EM_NUM 101 + + /* + * e_ident[EI_VERSION], e_version + */ + #define EV_NONE 0 + #define EV_CURRENT 1 + #define EV_NUM 2 + + /* + * Section header + */ + typedef struct { + Elf32_Word sh_name; + Elf32_Word sh_type; + Elf32_Word sh_flags; + Elf32_Addr sh_addr; + Elf32_Off sh_offset; + Elf32_Word sh_size; + Elf32_Word sh_link; + Elf32_Word sh_info; + Elf32_Word sh_addralign; + Elf32_Word sh_entsize; + } Elf32_Shdr; + + #if __LIBELF64 + typedef struct { + Elf64_Word sh_name; + Elf64_Word sh_type; + Elf64_Xword sh_flags; + Elf64_Addr sh_addr; + Elf64_Off sh_offset; + Elf64_Xword sh_size; + Elf64_Word sh_link; + Elf64_Word sh_info; + Elf64_Xword sh_addralign; + Elf64_Xword sh_entsize; + } Elf64_Shdr; + #endif /* __LIBELF64 */ + + /* + * Special section indices + */ + #define SHN_UNDEF 0 + #define SHN_LORESERVE 0xff00 + #define SHN_LOPROC 0xff00 + #define SHN_HIPROC 0xff1f + #define SHN_LOOS 0xff20 + #define SHN_HIOS 0xff3f + #define SHN_ABS 0xfff1 + #define SHN_COMMON 0xfff2 + #define SHN_XINDEX 0xffff + #define SHN_HIRESERVE 0xffff + + /* + * sh_type + */ + #define SHT_NULL 0 + #define SHT_PROGBITS 1 + #define SHT_SYMTAB 2 + #define SHT_STRTAB 3 + #define SHT_RELA 4 + #define SHT_HASH 5 + #define SHT_DYNAMIC 6 + #define SHT_NOTE 7 + #define SHT_NOBITS 8 + #define SHT_REL 9 + #define SHT_SHLIB 10 + #define SHT_DYNSYM 11 + #define SHT_INIT_ARRAY 14 + #define SHT_FINI_ARRAY 15 + #define SHT_PREINIT_ARRAY 16 + #define SHT_GROUP 17 + #define SHT_SYMTAB_SHNDX 18 + #define SHT_NUM 19 + #define SHT_LOOS 0x60000000 + #define SHT_HIOS 0x6fffffff + #define SHT_LOPROC 0x70000000 + #define SHT_HIPROC 0x7fffffff + #define SHT_LOUSER 0x80000000 + #define SHT_HIUSER 0xffffffff + + /* + * Solaris extensions + */ + #define SHT_SUNW_move 0x6ffffffa + #define SHT_SUNW_COMDAT 0x6ffffffb + #define SHT_SUNW_syminfo 0x6ffffffc + #define SHT_SUNW_verdef 0x6ffffffd + #define SHT_SUNW_verneed 0x6ffffffe + #define SHT_SUNW_versym 0x6fffffff + + /* + * GNU extensions + */ + #define SHT_GNU_verdef 0x6ffffffd + #define SHT_GNU_verneed 0x6ffffffe + #define SHT_GNU_versym 0x6fffffff + + /* + * sh_flags + */ + #define SHF_WRITE 0x1 + #define SHF_ALLOC 0x2 + #define SHF_EXECINSTR 0x4 + #define SHF_MERGE 0x10 + #define SHF_STRINGS 0x20 + #define SHF_INFO_LINK 0x40 + #define SHF_LINK_ORDER 0x80 + #define SHF_OS_NONCONFORMING 0x100 + #define SHF_GROUP 0x200 + #define SHF_TLS 0x400 + #define SHF_MASKOS 0x0ff00000 + #define SHF_MASKPROC 0xf0000000 + + /* + * Section group flags + */ + #define GRP_COMDAT 0x1 + #define GRP_MASKOS 0x0ff00000 + #define GRP_MASKPROC 0xf0000000 + + /* + * Symbol table + */ + typedef struct { + Elf32_Word st_name; + Elf32_Addr st_value; + Elf32_Word st_size; + unsigned char st_info; + unsigned char st_other; + Elf32_Half st_shndx; + } Elf32_Sym; + + #if __LIBELF64 + typedef struct { + Elf64_Word st_name; + unsigned char st_info; + unsigned char st_other; + Elf64_Half st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; + } Elf64_Sym; + #endif /* __LIBELF64 */ + + /* + * Special symbol indices + */ + #define STN_UNDEF 0 + + /* + * Macros for manipulating st_info + */ + #define ELF32_ST_BIND(i) ((i)>>4) + #define ELF32_ST_TYPE(i) ((i)&0xf) + #define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf)) + + #if __LIBELF64 + #define ELF64_ST_BIND(i) ((i)>>4) + #define ELF64_ST_TYPE(i) ((i)&0xf) + #define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf)) + #endif /* __LIBELF64 */ + + /* + * Symbol binding + */ + #define STB_LOCAL 0 + #define STB_GLOBAL 1 + #define STB_WEAK 2 + #define STB_NUM 3 + #define STB_LOOS 10 + #define STB_HIOS 12 + #define STB_LOPROC 13 + #define STB_HIPROC 15 + + /* + * Symbol types + */ + #define STT_NOTYPE 0 + #define STT_OBJECT 1 + #define STT_FUNC 2 + #define STT_SECTION 3 + #define STT_FILE 4 + #define STT_COMMON 5 + #define STT_TLS 6 + #define STT_NUM 7 + #define STT_LOOS 10 + #define STT_HIOS 12 + #define STT_LOPROC 13 + #define STT_HIPROC 15 + + /* + * Macros for manipulating st_other + */ + #define ELF32_ST_VISIBILITY(o) ((o)&0x3) + #if __LIBELF64 + #define ELF64_ST_VISIBILITY(o) ((o)&0x3) + #endif /* __LIBELF64 */ + + /* + * Symbol visibility + */ + #define STV_DEFAULT 0 + #define STV_INTERNAL 1 + #define STV_HIDDEN 2 + #define STV_PROTECTED 3 + + /* + * Relocation + */ + typedef struct { + Elf32_Addr r_offset; + Elf32_Word r_info; + } Elf32_Rel; + + typedef struct { + Elf32_Addr r_offset; + Elf32_Word r_info; + Elf32_Sword r_addend; + } Elf32_Rela; + + #if __LIBELF64 + typedef struct { + Elf64_Addr r_offset; + Elf64_Xword r_info; + } Elf64_Rel; + + typedef struct { + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; + } Elf64_Rela; + #endif /* __LIBELF64 */ + + /* + * Macros for manipulating r_info + */ + #define ELF32_R_SYM(i) ((i)>>8) + #define ELF32_R_TYPE(i) ((unsigned char)(i)) + #define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t)) + + #if __LIBELF64 + #define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32) + #define ELF64_R_TYPE(i) ((i)&0xffffffffL) + #define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL)) + #endif /* __LIBELF64 */ + + /* + * Note entry header + */ + typedef struct { + Elf32_Word n_namesz; /* name size */ + Elf32_Word n_descsz; /* descriptor size */ + Elf32_Word n_type; /* descriptor type */ + } Elf32_Nhdr; + + #if __LIBELF64 + /* Solaris and GNU use this layout. Be compatible. */ + /* XXX: Latest ELF specs say it's 64-bit?! */ + typedef struct { + Elf64_Word n_namesz; /* name size */ + Elf64_Word n_descsz; /* descriptor size */ + Elf64_Word n_type; /* descriptor type */ + } Elf64_Nhdr; + #endif /* __LIBELF64 */ + + /* + * Well-known descriptor types for ET_CORE files + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 + #define NT_PRPSINFO 3 + + /* + * Program header + */ + typedef struct { + Elf32_Word p_type; + Elf32_Off p_offset; + Elf32_Addr p_vaddr; + Elf32_Addr p_paddr; + Elf32_Word p_filesz; + Elf32_Word p_memsz; + Elf32_Word p_flags; + Elf32_Word p_align; + } Elf32_Phdr; + + #if __LIBELF64 + typedef struct { + Elf64_Word p_type; + Elf64_Word p_flags; + Elf64_Off p_offset; + Elf64_Addr p_vaddr; + Elf64_Addr p_paddr; + Elf64_Xword p_filesz; + Elf64_Xword p_memsz; + Elf64_Xword p_align; + } Elf64_Phdr; + #endif /* __LIBELF64 */ + + /* + * p_type + */ + #define PT_NULL 0 + #define PT_LOAD 1 + #define PT_DYNAMIC 2 + #define PT_INTERP 3 + #define PT_NOTE 4 + #define PT_SHLIB 5 + #define PT_PHDR 6 + #define PT_TLS 7 + #define PT_NUM 8 + #define PT_LOOS 0x60000000 + #define PT_HIOS 0x6fffffff + #define PT_LOPROC 0x70000000 + #define PT_HIPROC 0x7fffffff + + /* + * p_flags + */ + #define PF_X 0x1 + #define PF_W 0x2 + #define PF_R 0x4 + #define PF_MASKOS 0x0ff00000 + #define PF_MASKPROC 0xf0000000 + + /* + * Dynamic structure + */ + typedef struct { + Elf32_Sword d_tag; + union { + Elf32_Word d_val; + Elf32_Addr d_ptr; + } d_un; + } Elf32_Dyn; + + #if __LIBELF64 + typedef struct { + Elf64_Sxword d_tag; + union { + Elf64_Xword d_val; + Elf64_Addr d_ptr; + } d_un; + } Elf64_Dyn; + #endif /* __LIBELF64 */ + + /* + * Dynamic array tags + */ + /* d_un exec shared */ + #define DT_NULL 0 /* ign. mand. mand. */ + #define DT_NEEDED 1 /* d_val opt. opt. */ + #define DT_PLTRELSZ 2 /* d_val opt. opt. */ + #define DT_PLTGOT 3 /* d_ptr opt. opt. */ + #define DT_HASH 4 /* d_ptr mand. mand. */ + #define DT_STRTAB 5 /* d_ptr mand. mand. */ + #define DT_SYMTAB 6 /* d_ptr mand. mand. */ + #define DT_RELA 7 /* d_ptr mand. opt. */ + #define DT_RELASZ 8 /* d_val mand. opt. */ + #define DT_RELAENT 9 /* d_val mand. opt. */ + #define DT_STRSZ 10 /* d_val mand. mand. */ + #define DT_SYMENT 11 /* d_val mand. mand. */ + #define DT_INIT 12 /* d_ptr opt. opt. */ + #define DT_FINI 13 /* d_ptr opt. opt. */ + #define DT_SONAME 14 /* d_val ign. opt. */ + #define DT_RPATH 15 /* d_val opt. ign. */ + #define DT_SYMBOLIC 16 /* ign. ign. opt. */ + #define DT_REL 17 /* d_ptr mand. opt. */ + #define DT_RELSZ 18 /* d_val mand. opt. */ + #define DT_RELENT 19 /* d_val mand. opt. */ + #define DT_PLTREL 20 /* d_val opt. opt. */ + #define DT_DEBUG 21 /* d_ptr opt. ign. */ + #define DT_TEXTREL 22 /* ign. opt. opt. */ + #define DT_JMPREL 23 /* d_ptr opt. opt. */ + #define DT_BIND_NOW 24 /* ign. opt. opt. */ + #define DT_INIT_ARRAY 25 /* d_ptr opt. opt. */ + #define DT_FINI_ARRAY 26 /* d_ptr opt. opt. */ + #define DT_INIT_ARRAYSZ 27 /* d_val opt. opt. */ + #define DT_FINI_ARRAYSZ 28 /* d_val opt. opt. */ + #define DT_RUNPATH 29 /* d_val opt. opt. */ + #define DT_FLAGS 30 /* d_val opt. opt. */ + #define DT_ENCODING 32 /* odd/even encoding rule starts here */ + #define DT_PREINIT_ARRAY 32 /* d_ptr opt. ign. */ + #define DT_PREINIT_ARRAYSZ 33 /* d_val opt. ign. */ + #define DT_NUM 34 + #define DT_LOOS 0x6000000D + #define DT_HIOS 0x6ffff000 + #define DT_LOPROC 0x70000000 + #define DT_HIPROC 0x7fffffff + + /* + * DT_FLAGS values + */ + #define DF_ORIGIN 0x1 + #define DF_SYMBOLIC 0x2 + #define DF_TEXTREL 0x4 + #define DF_BIND_NOW 0x8 + #define DF_STATIC_TLS 0x10 + + /* + * Solaris extensions + */ + #define DT_VALRNGLO 0x6ffffd00 + #define DT_CHECKSUM 0x6ffffdf8 + #define DT_PLTPADSZ 0x6ffffdf9 + #define DT_MOVEENT 0x6ffffdfa + #define DT_MOVESZ 0x6ffffdfb + #define DT_FEATURE_1 0x6ffffdfc + #define DT_POSFLAG_1 0x6ffffdfd + #define DT_SYMINSZ 0x6ffffdfe + #define DT_SYMINENT 0x6ffffdff + #define DT_VALRNGHI 0x6ffffdff + + #define DT_ADDRRNGLO 0x6ffffe00 + #define DT_CONFIG 0x6ffffefa + #define DT_DEPAUDIT 0x6ffffefb + #define DT_AUDIT 0x6ffffefc + #define DT_PLTPAD 0x6ffffefd + #define DT_MOVETAB 0x6ffffefe + #define DT_SYMINFO 0x6ffffeff + #define DT_ADDRRNGHI 0x6ffffeff + + #define DT_RELACOUNT 0x6ffffff9 + #define DT_RELCOUNT 0x6ffffffa + #define DT_FLAGS_1 0x6ffffffb + #define DT_VERDEF 0x6ffffffc + #define DT_VERDEFNUM 0x6ffffffd + #define DT_VERNEED 0x6ffffffe + #define DT_VERNEEDNUM 0x6fffffff + + #define DT_AUXILIARY 0x7ffffffd + #define DT_USED 0x7ffffffe + #define DT_FILTER 0x7fffffff + + /* + * GNU extensions + */ + #define DT_VERSYM 0x6ffffff0 + + /* + * DT_FEATURE_1 values + */ + #define DTF_1_PARINIT 0x1 + #define DTF_1_CONFEXP 0x2 + + /* + * DT_POSFLAG_1 values + */ + #define DF_P1_LAZYLOAD 0x1 + #define DF_P1_GROUPPERM 0x2 + + /* + * DT_FLAGS_1 values + */ + #define DF_1_NOW 0x00000001 + #define DF_1_GLOBAL 0x00000002 + #define DF_1_GROUP 0x00000004 + #define DF_1_NODELETE 0x00000008 + #define DF_1_LOADFLTR 0x00000010 + #define DF_1_INITFIRST 0x00000020 + #define DF_1_NOOPEN 0x00000040 + #define DF_1_ORIGIN 0x00000080 + #define DF_1_DIRECT 0x00000100 + #define DF_1_TRANS 0x00000200 + #define DF_1_INTERPOSE 0x00000400 + #define DF_1_NODEFLIB 0x00000800 + #define DF_1_NODUMP 0x00001000 + #define DF_1_CONFALT 0x00002000 + #define DF_1_ENDFILTEE 0x00004000 + #define DF_1_DISPRELDNE 0x00008000 + #define DF_1_DISPRELPND 0x00010000 + + /* + * Syminfo structure + */ + typedef struct { + Elf32_Half si_boundto; + Elf32_Half si_flags; + } Elf32_Syminfo; + + #if __LIBELF64 + typedef struct { + Elf64_Half si_boundto; + Elf64_Half si_flags; + } Elf64_Syminfo; + #endif /* __LIBELF64 */ + + /* + * Syminfo version (stored in unused first entry) + */ + #define SYMINFO_NONE 0 + #define SYMINFO_CURRENT 1 + #define SYMINFO_NUM 2 + + /* + * si_boundto special values + */ + #define SYMINFO_BT_LOWRESERVE 0xff00 + #define SYMINFO_BT_PARENT 0xfffe /* bound to parent */ + #define SYMINFO_BT_SELF 0xffff /* bound to self */ + + /* + * si_flags + */ + #define SYMINFO_FLG_DIRECT 0x01 /* bound to an object */ + #define SYMINFO_FLG_PASSTHRU 0x02 /* pass-thru symbol */ + #define SYMINFO_FLG_COPY 0x04 /* result of a copy relocation */ + #define SYMINFO_FLG_LAZYLOAD 0x08 /* bound to lazy-loaded object */ + + /* + * Version definitions + */ + typedef struct { + Elf32_Half vd_version; + Elf32_Half vd_flags; + Elf32_Half vd_ndx; + Elf32_Half vd_cnt; + Elf32_Word vd_hash; + Elf32_Word vd_aux; + Elf32_Word vd_next; + } Elf32_Verdef; + + typedef struct { + Elf32_Word vda_name; + Elf32_Word vda_next; + } Elf32_Verdaux; + + typedef struct { + Elf32_Half vn_version; + Elf32_Half vn_cnt; + Elf32_Word vn_file; + Elf32_Word vn_aux; + Elf32_Word vn_next; + } Elf32_Verneed; + + typedef struct { + Elf32_Word vna_hash; + Elf32_Half vna_flags; + Elf32_Half vna_other; + Elf32_Word vna_name; + Elf32_Word vna_next; + } Elf32_Vernaux; + + typedef Elf32_Half Elf32_Versym; + + #if __LIBELF64 + + typedef struct { + Elf64_Half vd_version; + Elf64_Half vd_flags; + Elf64_Half vd_ndx; + Elf64_Half vd_cnt; + Elf64_Word vd_hash; + Elf64_Word vd_aux; + Elf64_Word vd_next; + } Elf64_Verdef; + + typedef struct { + Elf64_Word vda_name; + Elf64_Word vda_next; + } Elf64_Verdaux; + + typedef struct { + Elf64_Half vn_version; + Elf64_Half vn_cnt; + Elf64_Word vn_file; + Elf64_Word vn_aux; + Elf64_Word vn_next; + } Elf64_Verneed; + + typedef struct { + Elf64_Word vna_hash; + Elf64_Half vna_flags; + Elf64_Half vna_other; + Elf64_Word vna_name; + Elf64_Word vna_next; + } Elf64_Vernaux; + + typedef Elf64_Half Elf64_Versym; + + #endif /* __LIBELF64 */ + + /* + * vd_version + */ + #define VER_DEF_NONE 0 + #define VER_DEF_CURRENT 1 + #define VER_DEF_NUM 2 + + /* + * vn_version + */ + #define VER_NEED_NONE 0 + #define VER_NEED_CURRENT 1 + #define VER_NEED_NUM 2 + + /* + * vd_flags / vna_flags + */ + #define VER_FLG_BASE 0x1 /* vd_flags only */ + #define VER_FLG_WEAK 0x2 + + /* + * Elf*_Versym special values + */ + #define VER_NDX_LOCAL 0 + #define VER_NDX_GLOBAL 1 + + /* + * Move section + */ + #if __LIBELF64 + + typedef struct { + Elf32_Lword m_value; + Elf32_Word m_info; + Elf32_Word m_poffset; + Elf32_Half m_repeat; + Elf32_Half m_stride; + } Elf32_Move; + + typedef struct { + Elf64_Lword m_value; + Elf64_Xword m_info; + Elf64_Xword m_poffset; + Elf64_Half m_repeat; + Elf64_Half m_stride; + } Elf64_Move; + + #define ELF32_M_SYM(info) ((info)>>8) + #define ELF32_M_SIZE(info) ((unsigned char)(info)) + #define ELF32_M_INFO(sym, sz) (((sym)<<8)+(unsigned char)(sz)) + + #define ELF64_M_SYM(info) ((Elf64_Xword)(info)>>8) + #define ELF64_M_SIZE(info) ((unsigned char)(info)) + #define ELF64_M_INFO(sym, sz) (((Elf64_Xword)(sym)<<8)+(unsigned char)(sz)) + + #endif /* __LIBELF64 */ + + #ifdef __cplusplus + } + #endif /* __cplusplus */ + + #endif /* _ELF_REPL_H */ Index: llvm/lib/CodeGen/ELF/lib/end.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/end.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/end.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,122 ---- + /* + end.c - implementation of the elf_end(3) function. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: end.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_MMAP + #include + #endif /* HAVE_MMAP */ + + static void + _elf_free(void *ptr) { + if (ptr) { + free(ptr); + } + } + + static void + _elf_free_scns(Elf *elf, Elf_Scn *scn) { + Scn_Data *sd, *tmp; + Elf_Scn *freescn; + + for (freescn = NULL; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + for (sd = scn->s_data_1; sd; sd = tmp) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + tmp = sd->sd_link; + if (sd->sd_free_data) { + _elf_free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if ((sd = scn->s_rawdata)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (sd->sd_free_data) { + _elf_free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if (scn->s_freeme) { + _elf_free(freescn); + freescn = scn; + } + } + _elf_free(freescn); + } + + int + elf_end(Elf *elf) { + Elf **siblings; + + if (!elf) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (--elf->e_count) { + return elf->e_count; + } + if (elf->e_parent) { + elf_assert(elf->e_parent->e_magic == ELF_MAGIC); + elf_assert(elf->e_parent->e_kind == ELF_K_AR); + siblings = &elf->e_parent->e_members; + while (*siblings) { + if (*siblings == elf) { + *siblings = elf->e_link; + break; + } + siblings = &(*siblings)->e_link; + } + elf_end(elf->e_parent); + _elf_free(elf->e_arhdr); + } + #if HAVE_MMAP + else if (elf->e_unmap_data) { + munmap(elf->e_data, elf->e_size); + } + #endif /* HAVE_MMAP */ + else if (!elf->e_memory) { + _elf_free(elf->e_data); + } + _elf_free_scns(elf, elf->e_scn_1); + if (elf->e_rawdata != elf->e_data) { + _elf_free(elf->e_rawdata); + } + if (elf->e_free_syms) { + _elf_free(elf->e_symtab); + } + if (elf->e_free_ehdr) { + _elf_free(elf->e_ehdr); + } + if (elf->e_free_phdr) { + _elf_free(elf->e_phdr); + } + free(elf); + return 0; + } Index: llvm/lib/CodeGen/ELF/lib/errmsg.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/errmsg.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/errmsg.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,77 ---- + /* + errmsg.c - implementation of the elf_errmsg(3) function. + Copyright (C) 1995 - 1999 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: errmsg.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_GETTEXT + # undef HAVE_CATGETS + # include + #else /* HAVE_GETTEXT */ + # define dgettext(dom, str) str + #endif /* HAVE_GETTEXT */ + + #if HAVE_CATGETS + # include + static nl_catd _libelf_cat = (nl_catd)0; + #endif /* HAVE_CATGETS */ + + #if HAVE_GETTEXT || HAVE_CATGETS + static const char domain[] = "libelf"; + #endif /* HAVE_GETTEXT || HAVE_CATGETS */ + + #if PIC + static const char *_messages[] = { + #else /* PIC */ + static const char *const _messages[] = { + #endif /* PIC */ + #define __err__(a,b) b, + #include /* include string tables from errors.h */ + #undef __err__ + }; + + const char* + elf_errmsg(int err) { + if (err == 0) { + err = _elf_errno; + if (err == 0) { + return NULL; + } + } + else if (err == -1) { + err = _elf_errno; + } + + if (err < 0 || err >= ERROR_NUM || _messages[err] == NULL) { + err = ERROR_UNKNOWN; + } + + #if HAVE_CATGETS + if (_libelf_cat == (nl_catd)0) { + _libelf_cat = catopen(domain, 0); + } + if (_libelf_cat != (nl_catd)-1) { + return catgets(_libelf_cat, 1, err + 1, _messages[err]); + } + #endif /* HAVE_CATGETS */ + return dgettext(domain, _messages[err]); + } Index: llvm/lib/CodeGen/ELF/lib/errno.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/errno.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/errno.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,32 ---- + /* + errno.c - implementation of the elf_errno(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: errno.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + int + elf_errno(void) { + int tmp = _elf_errno; + + _elf_errno = 0; + return tmp; + } Index: llvm/lib/CodeGen/ELF/lib/errors.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/errors.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/errors.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,98 ---- + /* + errors.h - exhaustive list of all error codes and messages for libelf. + Copyright (C) 1995 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: errors.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + /* dummy for xgettext */ + #define _(str) str + + __err__(ERROR_OK, _("no error")) + __err__(ERROR_UNKNOWN, _("unknown error")) + __err__(ERROR_INTERNAL, _("Internal error: unknown reason")) + __err__(ERROR_UNIMPLEMENTED, _("Internal error: not implemented")) + __err__(ERROR_WRONLY, _("Request error: cntl(ELF_C_FDREAD) on write-only file")) + __err__(ERROR_INVALID_CMD, _("Request error: invalid ELF_C_* argument")) + __err__(ERROR_FDDISABLED, _("Request error: file descriptor disabled")) + __err__(ERROR_NOTARCHIVE, _("Request error: not an archive")) + __err__(ERROR_BADOFF, _("Request error: offset out of range")) + __err__(ERROR_UNKNOWN_VERSION, _("Request error: unknown ELF version")) + __err__(ERROR_CMDMISMATCH, _("Request error: ELF_C_* argument does not match")) + __err__(ERROR_MEMBERWRITE, _("Request error: archive member begin() for writing")) + __err__(ERROR_FDMISMATCH, _("Request error: archive/member file descriptor mismatch")) + __err__(ERROR_NOTELF, _("Request error: not an ELF file")) + __err__(ERROR_CLASSMISMATCH, _("Request error: class file/memory mismatch")) + __err__(ERROR_UNKNOWN_TYPE, _("Request error: invalid ELF_T_* argument")) + __err__(ERROR_UNKNOWN_ENCODING, _("Request error: unknown data encoding")) + __err__(ERROR_DST2SMALL, _("Request error: destination buffer too small")) + __err__(ERROR_NULLBUF, _("Request error: d_buf is NULL")) + __err__(ERROR_UNKNOWN_CLASS, _("Request error: unknown ELF class")) + __err__(ERROR_ELFSCNMISMATCH, _("Request error: section does not belong to file")) + __err__(ERROR_NOSUCHSCN, _("Request error: no section at index")) + __err__(ERROR_NULLSCN, _("Request error: can't manipulate null section")) + __err__(ERROR_SCNDATAMISMATCH, _("Request error: data does not belong to section")) + __err__(ERROR_NOSTRTAB, _("Request error: no string table")) + __err__(ERROR_BADSTROFF, _("Request error: string table offset out of range")) + __err__(ERROR_RDONLY, _("Request error: update(ELF_C_WRITE) on read-only file")) + __err__(ERROR_IO_SEEK, _("I/O error: seek")) + __err__(ERROR_IO_2BIG, _("I/O error: file too big for memory")) + __err__(ERROR_IO_READ, _("I/O error: raw read")) + __err__(ERROR_IO_GETSIZE, _("I/O error: get file size")) + __err__(ERROR_IO_WRITE, _("I/O error: output write")) + __err__(ERROR_IO_TRUNC, _("I/O error: can't truncate output file")) + __err__(ERROR_VERSION_UNSET, _("Sequence error: must set ELF version first")) + __err__(ERROR_NOEHDR, _("Sequence error: must create ELF header first")) + __err__(ERROR_OUTSIDE, _("Format error: reference outside file")) + __err__(ERROR_TRUNC_ARHDR, _("Format error: archive header truncated")) + __err__(ERROR_ARFMAG, _("Format error: archive fmag")) + __err__(ERROR_ARHDR, _("Format error: archive header")) + __err__(ERROR_TRUNC_MEMBER, _("Format error: archive member truncated")) + __err__(ERROR_SIZE_ARSYMTAB, _("Format error: archive symbol table size")) + __err__(ERROR_ARSTRTAB, _("Format error: archive string table")) + __err__(ERROR_ARSPECIAL, _("Format error: archive special name unknown")) + __err__(ERROR_TRUNC_EHDR, _("Format error: ELF header truncated")) + __err__(ERROR_TRUNC_PHDR, _("Format error: program header table truncated")) + __err__(ERROR_TRUNC_SHDR, _("Format error: section header table truncated")) + __err__(ERROR_TRUNC_SCN, _("Format error: data region truncated")) + __err__(ERROR_ALIGN_PHDR, _("Format error: program header table alignment")) + __err__(ERROR_ALIGN_SHDR, _("Format error: section header table alignment")) + __err__(ERROR_VERDEF_FORMAT, _("Format error: bad parameter in Verdef record")) + __err__(ERROR_VERDEF_VERSION, _("Format error: unknown Verdef version")) + __err__(ERROR_VERNEED_FORMAT, _("Format error: bad parameter in Verneed record")) + __err__(ERROR_VERNEED_VERSION, _("Format error: unknown Verneed version")) + __err__(ERROR_EHDR_SHNUM, _("Format error: bad e_shnum value")) + __err__(ERROR_UNTERM, _("Format error: unterminated string in string table")) + __err__(ERROR_SCN2SMALL, _("Layout error: section size too small for data")) + __err__(ERROR_SCN_OVERLAP, _("Layout error: overlapping sections")) + __err__(ERROR_MEM_ELF, _("Memory error: elf descriptor")) + __err__(ERROR_MEM_ARSYMTAB, _("Memory error: archive symbol table")) + __err__(ERROR_MEM_ARHDR, _("Memory error: archive member header")) + __err__(ERROR_MEM_EHDR, _("Memory error: ELF header")) + __err__(ERROR_MEM_PHDR, _("Memory error: program header table")) + __err__(ERROR_MEM_SHDR, _("Memory error: section header table")) + __err__(ERROR_MEM_SCN, _("Memory error: section descriptor")) + __err__(ERROR_MEM_SCNDATA, _("Memory error: section data")) + __err__(ERROR_MEM_OUTBUF, _("Memory error: output file space")) + __err__(ERROR_MEM_TEMPORARY, _("Memory error: temporary buffer")) + __err__(ERROR_BADVALUE, _("GElf error: value out of range")) + __err__(ERROR_BADINDEX, _("GElf error: index out of range")) + __err__(ERROR_BADTYPE, _("GElf error: type mismatch")) + __err__(ERROR_MEM_SYM, _("GElf error: not enough memory for GElf_Sym")) + __err__(ERROR_MEM_DYN, _("GElf error: not enough memory for GElf_Dyn")) + __err__(ERROR_MEM_RELA, _("GElf error: not enough memory for GElf_Rela")) + __err__(ERROR_MEM_REL, _("GElf error: not enough memory for GElf_Rel")) Index: llvm/lib/CodeGen/ELF/lib/ext_types.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/ext_types.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/ext_types.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,334 ---- + /* + ext_types.h - external representation of ELF data types. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: ext_types.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _EXT_TYPES_H + #define _EXT_TYPES_H + + #ifdef __cplusplus + extern "C" { + #endif /* __cplusplus */ + + /* + * Scalar data types + */ + typedef unsigned char __ext_Elf32_Addr [ELF32_FSZ_ADDR]; + typedef unsigned char __ext_Elf32_Half [ELF32_FSZ_HALF]; + typedef unsigned char __ext_Elf32_Off [ELF32_FSZ_OFF]; + typedef unsigned char __ext_Elf32_Sword [ELF32_FSZ_SWORD]; + typedef unsigned char __ext_Elf32_Word [ELF32_FSZ_WORD]; + + #if __LIBELF64 + + typedef unsigned char __ext_Elf32_Lword [8]; + + typedef unsigned char __ext_Elf64_Addr [ELF64_FSZ_ADDR]; + typedef unsigned char __ext_Elf64_Half [ELF64_FSZ_HALF]; + typedef unsigned char __ext_Elf64_Off [ELF64_FSZ_OFF]; + typedef unsigned char __ext_Elf64_Sword [ELF64_FSZ_SWORD]; + typedef unsigned char __ext_Elf64_Word [ELF64_FSZ_WORD]; + typedef unsigned char __ext_Elf64_Sxword[ELF64_FSZ_SXWORD]; + typedef unsigned char __ext_Elf64_Xword [ELF64_FSZ_XWORD]; + + typedef unsigned char __ext_Elf64_Lword [8]; + + #endif /* __LIBELF64 */ + + /* + * ELF header + */ + typedef struct { + unsigned char e_ident[EI_NIDENT]; + __ext_Elf32_Half e_type; + __ext_Elf32_Half e_machine; + __ext_Elf32_Word e_version; + __ext_Elf32_Addr e_entry; + __ext_Elf32_Off e_phoff; + __ext_Elf32_Off e_shoff; + __ext_Elf32_Word e_flags; + __ext_Elf32_Half e_ehsize; + __ext_Elf32_Half e_phentsize; + __ext_Elf32_Half e_phnum; + __ext_Elf32_Half e_shentsize; + __ext_Elf32_Half e_shnum; + __ext_Elf32_Half e_shstrndx; + } __ext_Elf32_Ehdr; + + #if __LIBELF64 + typedef struct { + unsigned char e_ident[EI_NIDENT]; + __ext_Elf64_Half e_type; + __ext_Elf64_Half e_machine; + __ext_Elf64_Word e_version; + __ext_Elf64_Addr e_entry; + __ext_Elf64_Off e_phoff; + __ext_Elf64_Off e_shoff; + __ext_Elf64_Word e_flags; + __ext_Elf64_Half e_ehsize; + __ext_Elf64_Half e_phentsize; + __ext_Elf64_Half e_phnum; + __ext_Elf64_Half e_shentsize; + __ext_Elf64_Half e_shnum; + __ext_Elf64_Half e_shstrndx; + } __ext_Elf64_Ehdr; + #endif /* __LIBELF64 */ + + /* + * Section header + */ + typedef struct { + __ext_Elf32_Word sh_name; + __ext_Elf32_Word sh_type; + __ext_Elf32_Word sh_flags; + __ext_Elf32_Addr sh_addr; + __ext_Elf32_Off sh_offset; + __ext_Elf32_Word sh_size; + __ext_Elf32_Word sh_link; + __ext_Elf32_Word sh_info; + __ext_Elf32_Word sh_addralign; + __ext_Elf32_Word sh_entsize; + } __ext_Elf32_Shdr; + + #if __LIBELF64 + typedef struct { + __ext_Elf64_Word sh_name; + __ext_Elf64_Word sh_type; + __ext_Elf64_Xword sh_flags; + __ext_Elf64_Addr sh_addr; + __ext_Elf64_Off sh_offset; + __ext_Elf64_Xword sh_size; + __ext_Elf64_Word sh_link; + __ext_Elf64_Word sh_info; + __ext_Elf64_Xword sh_addralign; + __ext_Elf64_Xword sh_entsize; + } __ext_Elf64_Shdr; + #endif /* __LIBELF64 */ + + /* + * Symbol table + */ + typedef struct { + __ext_Elf32_Word st_name; + __ext_Elf32_Addr st_value; + __ext_Elf32_Word st_size; + unsigned char st_info; + unsigned char st_other; + __ext_Elf32_Half st_shndx; + } __ext_Elf32_Sym; + + #if __LIBELF64 + typedef struct { + __ext_Elf64_Word st_name; + unsigned char st_info; + unsigned char st_other; + __ext_Elf64_Half st_shndx; + __ext_Elf64_Addr st_value; + __ext_Elf64_Xword st_size; + } __ext_Elf64_Sym; + #endif /* __LIBELF64 */ + + /* + * Relocation + */ + typedef struct { + __ext_Elf32_Addr r_offset; + __ext_Elf32_Word r_info; + } __ext_Elf32_Rel; + + typedef struct { + __ext_Elf32_Addr r_offset; + __ext_Elf32_Word r_info; + __ext_Elf32_Sword r_addend; + } __ext_Elf32_Rela; + + #if __LIBELF64 + typedef struct { + __ext_Elf64_Addr r_offset; + #if __LIBELF64_IRIX + __ext_Elf64_Word r_sym; + unsigned char r_ssym; + unsigned char r_type3; + unsigned char r_type2; + unsigned char r_type; + #else /* __LIBELF64_IRIX */ + __ext_Elf64_Xword r_info; + #endif /* __LIBELF64_IRIX */ + } __ext_Elf64_Rel; + + typedef struct { + __ext_Elf64_Addr r_offset; + #if __LIBELF64_IRIX + __ext_Elf64_Word r_sym; + unsigned char r_ssym; + unsigned char r_type3; + unsigned char r_type2; + unsigned char r_type; + #else /* __LIBELF64_IRIX */ + __ext_Elf64_Xword r_info; + #endif /* __LIBELF64_IRIX */ + __ext_Elf64_Sxword r_addend; + } __ext_Elf64_Rela; + #endif /* __LIBELF64 */ + + /* + * Program header + */ + typedef struct { + __ext_Elf32_Word p_type; + __ext_Elf32_Off p_offset; + __ext_Elf32_Addr p_vaddr; + __ext_Elf32_Addr p_paddr; + __ext_Elf32_Word p_filesz; + __ext_Elf32_Word p_memsz; + __ext_Elf32_Word p_flags; + __ext_Elf32_Word p_align; + } __ext_Elf32_Phdr; + + #if __LIBELF64 + typedef struct { + __ext_Elf64_Word p_type; + __ext_Elf64_Word p_flags; + __ext_Elf64_Off p_offset; + __ext_Elf64_Addr p_vaddr; + __ext_Elf64_Addr p_paddr; + __ext_Elf64_Xword p_filesz; + __ext_Elf64_Xword p_memsz; + __ext_Elf64_Xword p_align; + } __ext_Elf64_Phdr; + #endif /* __LIBELF64 */ + + /* + * Dynamic structure + */ + typedef struct { + __ext_Elf32_Sword d_tag; + union { + __ext_Elf32_Word d_val; + __ext_Elf32_Addr d_ptr; + } d_un; + } __ext_Elf32_Dyn; + + #if __LIBELF64 + typedef struct { + __ext_Elf64_Sxword d_tag; + union { + __ext_Elf64_Xword d_val; + __ext_Elf64_Addr d_ptr; + } d_un; + } __ext_Elf64_Dyn; + #endif /* __LIBELF64 */ + + /* + * Version definitions + */ + typedef struct { + __ext_Elf32_Half vd_version; + __ext_Elf32_Half vd_flags; + __ext_Elf32_Half vd_ndx; + __ext_Elf32_Half vd_cnt; + __ext_Elf32_Word vd_hash; + __ext_Elf32_Word vd_aux; + __ext_Elf32_Word vd_next; + } __ext_Elf32_Verdef; + + typedef struct { + __ext_Elf32_Word vda_name; + __ext_Elf32_Word vda_next; + } __ext_Elf32_Verdaux; + + typedef struct { + __ext_Elf32_Half vn_version; + __ext_Elf32_Half vn_cnt; + __ext_Elf32_Word vn_file; + __ext_Elf32_Word vn_aux; + __ext_Elf32_Word vn_next; + } __ext_Elf32_Verneed; + + typedef struct { + __ext_Elf32_Word vna_hash; + __ext_Elf32_Half vna_flags; + __ext_Elf32_Half vna_other; + __ext_Elf32_Word vna_name; + __ext_Elf32_Word vna_next; + } __ext_Elf32_Vernaux; + + #if __LIBELF64 + + typedef struct { + __ext_Elf64_Half vd_version; + __ext_Elf64_Half vd_flags; + __ext_Elf64_Half vd_ndx; + __ext_Elf64_Half vd_cnt; + __ext_Elf64_Word vd_hash; + __ext_Elf64_Word vd_aux; + __ext_Elf64_Word vd_next; + } __ext_Elf64_Verdef; + + typedef struct { + __ext_Elf64_Word vda_name; + __ext_Elf64_Word vda_next; + } __ext_Elf64_Verdaux; + + typedef struct { + __ext_Elf64_Half vn_version; + __ext_Elf64_Half vn_cnt; + __ext_Elf64_Word vn_file; + __ext_Elf64_Word vn_aux; + __ext_Elf64_Word vn_next; + } __ext_Elf64_Verneed; + + typedef struct { + __ext_Elf64_Word vna_hash; + __ext_Elf64_Half vna_flags; + __ext_Elf64_Half vna_other; + __ext_Elf64_Word vna_name; + __ext_Elf64_Word vna_next; + } __ext_Elf64_Vernaux; + + #endif /* __LIBELF64 */ + + /* + * Move section + */ + #if __LIBELF64 + + typedef struct { + __ext_Elf32_Lword m_value; + __ext_Elf32_Word m_info; + __ext_Elf32_Word m_poffset; + __ext_Elf32_Half m_repeat; + __ext_Elf32_Half m_stride; + } __ext_Elf32_Move; + + typedef struct { + __ext_Elf64_Lword m_value; + __ext_Elf64_Xword m_info; + __ext_Elf64_Xword m_poffset; + __ext_Elf64_Half m_repeat; + __ext_Elf64_Half m_stride; + } __ext_Elf64_Move; + + #endif /* __LIBELF64 */ + + #ifdef __cplusplus + } + #endif /* __cplusplus */ + + #endif /* _EXT_TYPES_H */ Index: llvm/lib/CodeGen/ELF/lib/fill.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/fill.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/fill.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,29 ---- + /* + fill.c - implementation of the elf_fill(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: fill.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + void + elf_fill(int fill) { + _elf_fill = fill; + } Index: llvm/lib/CodeGen/ELF/lib/flag.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/flag.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/flag.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,92 ---- + /* + flag.c - implementation of the elf_flag*(3) functions. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: flag.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + static unsigned + _elf_flag(unsigned *f, Elf_Cmd cmd, unsigned flags) { + if (cmd == ELF_C_SET) { + return *f |= flags; + } + if (cmd == ELF_C_CLR) { + return *f &= ~flags; + } + seterr(ERROR_INVALID_CMD); + return 0; + } + + unsigned + elf_flagdata(Elf_Data *data, Elf_Cmd cmd, unsigned flags) { + Scn_Data *sd = (Scn_Data*)data; + + if (!sd) { + return 0; + } + elf_assert(sd->sd_magic == DATA_MAGIC); + return _elf_flag(&sd->sd_data_flags, cmd, flags); + } + + unsigned + elf_flagehdr(Elf *elf, Elf_Cmd cmd, unsigned flags) { + if (!elf) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + return _elf_flag(&elf->e_ehdr_flags, cmd, flags); + } + + unsigned + elf_flagelf(Elf *elf, Elf_Cmd cmd, unsigned flags) { + if (!elf) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + return _elf_flag(&elf->e_elf_flags, cmd, flags); + } + + unsigned + elf_flagphdr(Elf *elf, Elf_Cmd cmd, unsigned flags) { + if (!elf) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + return _elf_flag(&elf->e_phdr_flags, cmd, flags); + } + + unsigned + elf_flagscn(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) { + if (!scn) { + return 0; + } + elf_assert(scn->s_magic == SCN_MAGIC); + return _elf_flag(&scn->s_scn_flags, cmd, flags); + } + + unsigned + elf_flagshdr(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) { + if (!scn) { + return 0; + } + elf_assert(scn->s_magic == SCN_MAGIC); + return _elf_flag(&scn->s_shdr_flags, cmd, flags); + } Index: llvm/lib/CodeGen/ELF/lib/gelf.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/gelf.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/gelf.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,153 ---- + /* + gelf.h - public header file for libelf. + Copyright (C) 2000 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: gelf.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _GELF_H + #define _GELF_H + + #if __LIBELF_INTERNAL__ + #include + #else /* __LIBELF_INTERNAL__ */ + #include + #endif /* __LIBELF_INTERNAL__ */ + + #if __LIBELF_NEED_LINK_H + #include + #endif /* __LIBELF_NEED_LINK_H */ + + #ifdef __cplusplus + extern "C" { + #endif /* __cplusplus */ + + #ifndef __P + # if __STDC__ || defined(__cplusplus) + # define __P(args) args + # else /* __STDC__ || defined(__cplusplus) */ + # define __P(args) () + # endif /* __STDC__ || defined(__cplusplus) */ + #endif /* __P */ + + #if !__LIBELF64 + + #error "GElf is not supported on this system." + + #else /* __LIBELF64 */ + + typedef Elf64_Addr GElf_Addr; + typedef Elf64_Half GElf_Half; + typedef Elf64_Off GElf_Off; + typedef Elf64_Sword GElf_Sword; + typedef Elf64_Word GElf_Word; + typedef Elf64_Sxword GElf_Sxword; + typedef Elf64_Xword GElf_Xword; + + typedef Elf64_Ehdr GElf_Ehdr; + typedef Elf64_Phdr GElf_Phdr; + typedef Elf64_Shdr GElf_Shdr; + typedef Elf64_Dyn GElf_Dyn; + typedef Elf64_Rel GElf_Rel; + typedef Elf64_Rela GElf_Rela; + typedef Elf64_Sym GElf_Sym; + + /* + * Symbol versioning + */ + #if __LIBELF_SYMBOL_VERSIONS + typedef Elf64_Verdef GElf_Verdef; + typedef Elf64_Verneed GElf_Verneed; + typedef Elf64_Verdaux GElf_Verdaux; + typedef Elf64_Vernaux GElf_Vernaux; + #endif /* __LIBELF_SYMBOL_VERSIONS */ + + /* + * These types aren't implemented (yet) + * + typedef Elf64_Move GElf_Move; + typedef Elf64_Syminfo GElf_Syminfo; + */ + + /* + * Generic macros + */ + #define GELF_ST_BIND ELF64_ST_BIND + #define GELF_ST_TYPE ELF64_ST_TYPE + #define GELF_ST_INFO ELF64_ST_INFO + + #define GELF_R_TYPE ELF64_R_TYPE + #define GELF_R_SYM ELF64_R_SYM + #define GELF_R_INFO ELF64_R_INFO + + /* + * Function declarations + */ + extern int gelf_getclass __P((Elf *__elf)); + + extern size_t gelf_fsize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver)); + + extern Elf_Data *gelf_xlatetof __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode)); + extern Elf_Data *gelf_xlatetom __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode)); + + extern GElf_Ehdr *gelf_getehdr __P((Elf *__elf, GElf_Ehdr *__dst)); + extern int gelf_update_ehdr __P((Elf *__elf, GElf_Ehdr *__src)); + extern unsigned long gelf_newehdr __P((Elf *__elf, int __elfclass)); + + extern GElf_Phdr *gelf_getphdr __P((Elf *__elf, int ndx, GElf_Phdr *__dst)); + extern int gelf_update_phdr __P((Elf *__elf, int ndx, GElf_Phdr *__src)); + extern unsigned long gelf_newphdr __P((Elf *__elf, size_t __phnum)); + + extern GElf_Shdr *gelf_getshdr __P((Elf_Scn *__scn, GElf_Shdr *__dst)); + extern int gelf_update_shdr __P((Elf_Scn *__scn, GElf_Shdr *__src)); + + extern GElf_Dyn *gelf_getdyn __P((Elf_Data *__src, int __ndx, GElf_Dyn *__dst)); + extern int gelf_update_dyn __P((Elf_Data *__dst, int __ndx, GElf_Dyn *__src)); + + extern GElf_Rel *gelf_getrel __P((Elf_Data *__src, int __ndx, GElf_Rel *__dst)); + extern int gelf_update_rel __P((Elf_Data *__dst, int __ndx, GElf_Rel *__src)); + + extern GElf_Rela *gelf_getrela __P((Elf_Data *__src, int __ndx, GElf_Rela *__dst)); + extern int gelf_update_rela __P((Elf_Data *__dst, int __ndx, GElf_Rela *__src)); + + extern GElf_Sym *gelf_getsym __P((Elf_Data *__src, int __ndx, GElf_Sym *__dst)); + extern int gelf_update_sym __P((Elf_Data *__dst, int __ndx, GElf_Sym *__src)); + + extern long gelf_checksum __P((Elf *__elf)); + + /* + * These functions aren't implemented (yet) + * + extern GElf_Move *gelf_getmove __P((Elf_Data *__src, int __ndx, GElf_Move *__src)); + extern int gelf_update_move __P((Elf_Data *__dst, int __ndx, GElf_Move *__src)); + * + extern GElf_Syminfo* gelf_getsyminfo __P((Elf_Data *__src, int __ndx, GElf_Syminfo *__dst)); + extern int gelf_update_syminfo __P((Elf_Data *__dst, int __ndx, GElf_Syminfo *__src)); + */ + + /* + * Extensions (not available in other versions of libelf) + */ + extern size_t gelf_msize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver)); + + #endif /* __LIBELF64 */ + + #ifdef __cplusplus + } + #endif /* __cplusplus */ + + #endif /* _GELF_H */ Index: llvm/lib/CodeGen/ELF/lib/gelfehdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/gelfehdr.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/gelfehdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,138 ---- + /* + gelfehdr.c - gelf_* translation functions. + Copyright (C) 2000 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: gelfehdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #define check_and_copy(type, d, s, name, eret) \ + do { \ + if (sizeof((d)->name) < sizeof((s)->name) \ + && (type)(s)->name != (s)->name) { \ + seterr(ERROR_BADVALUE); \ + return (eret); \ + } \ + (d)->name = (type)(s)->name; \ + } while (0) + + GElf_Ehdr* + gelf_getehdr(Elf *elf, GElf_Ehdr *dst) { + GElf_Ehdr buf; + char *tmp; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + tmp = _elf_getehdr(elf, elf->e_class); + if (!tmp) { + return NULL; + } + if (!dst) { + dst = &buf; + } + if (elf->e_class == ELFCLASS64) { + *dst = *(Elf64_Ehdr*)tmp; + } + else if (elf->e_class == ELFCLASS32) { + Elf32_Ehdr *src = (Elf32_Ehdr*)tmp; + + memcpy(dst->e_ident, src->e_ident, EI_NIDENT); + check_and_copy(GElf_Half, dst, src, e_type, NULL); + check_and_copy(GElf_Half, dst, src, e_machine, NULL); + check_and_copy(GElf_Word, dst, src, e_version, NULL); + check_and_copy(GElf_Addr, dst, src, e_entry, NULL); + check_and_copy(GElf_Off, dst, src, e_phoff, NULL); + check_and_copy(GElf_Off, dst, src, e_shoff, NULL); + check_and_copy(GElf_Word, dst, src, e_flags, NULL); + check_and_copy(GElf_Half, dst, src, e_ehsize, NULL); + check_and_copy(GElf_Half, dst, src, e_phentsize, NULL); + check_and_copy(GElf_Half, dst, src, e_phnum, NULL); + check_and_copy(GElf_Half, dst, src, e_shentsize, NULL); + check_and_copy(GElf_Half, dst, src, e_shnum, NULL); + check_and_copy(GElf_Half, dst, src, e_shstrndx, NULL); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Ehdr*)malloc(sizeof(GElf_Ehdr)); + if (!dst) { + seterr(ERROR_MEM_EHDR); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_ehdr(Elf *elf, GElf_Ehdr *src) { + char *tmp; + + if (!elf || !src) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + tmp = _elf_getehdr(elf, elf->e_class); + if (!tmp) { + return 0; + } + if (elf->e_class == ELFCLASS64) { + *(Elf64_Ehdr*)tmp = *src; + } + else if (elf->e_class == ELFCLASS32) { + Elf32_Ehdr *dst = (Elf32_Ehdr*)tmp; + + memcpy(dst->e_ident, src->e_ident, EI_NIDENT); + check_and_copy(Elf32_Half, dst, src, e_type, 0); + check_and_copy(Elf32_Half, dst, src, e_machine, 0); + check_and_copy(Elf32_Word, dst, src, e_version, 0); + check_and_copy(Elf32_Addr, dst, src, e_entry, 0); + check_and_copy(Elf32_Off, dst, src, e_phoff, 0); + check_and_copy(Elf32_Off, dst, src, e_shoff, 0); + check_and_copy(Elf32_Word, dst, src, e_flags, 0); + check_and_copy(Elf32_Half, dst, src, e_ehsize, 0); + check_and_copy(Elf32_Half, dst, src, e_phentsize, 0); + check_and_copy(Elf32_Half, dst, src, e_phnum, 0); + check_and_copy(Elf32_Half, dst, src, e_shentsize, 0); + check_and_copy(Elf32_Half, dst, src, e_shnum, 0); + check_and_copy(Elf32_Half, dst, src, e_shstrndx, 0); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return 0; + } + return 1; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/gelfphdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/gelfphdr.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/gelfphdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,146 ---- + /* + gelfphdr.c - gelf_* translation functions. + Copyright (C) 2000 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: gelfphdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #define check_and_copy(type, d, s, name, eret) \ + do { \ + if (sizeof((d)->name) < sizeof((s)->name) \ + && (type)(s)->name != (s)->name) { \ + seterr(ERROR_BADVALUE); \ + return (eret); \ + } \ + (d)->name = (type)(s)->name; \ + } while (0) + + GElf_Phdr* + gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst) { + GElf_Phdr buf; + char *tmp; + size_t n; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + tmp = _elf_getphdr(elf, elf->e_class); + if (!tmp) { + return NULL; + } + if (ndx < 0 || ndx >= elf->e_phnum) { + seterr(ERROR_BADINDEX); + return NULL; + } + n = _msize(elf->e_class, _elf_version, ELF_T_PHDR); + if (n == 0) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (!dst) { + dst = &buf; + } + if (elf->e_class == ELFCLASS64) { + *dst = *(Elf64_Phdr*)(tmp + ndx * n); + } + else if (elf->e_class == ELFCLASS32) { + Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n); + + check_and_copy(GElf_Word, dst, src, p_type, NULL); + check_and_copy(GElf_Word, dst, src, p_flags, NULL); + check_and_copy(GElf_Off, dst, src, p_offset, NULL); + check_and_copy(GElf_Addr, dst, src, p_vaddr, NULL); + check_and_copy(GElf_Addr, dst, src, p_paddr, NULL); + check_and_copy(GElf_Xword, dst, src, p_filesz, NULL); + check_and_copy(GElf_Xword, dst, src, p_memsz, NULL); + check_and_copy(GElf_Xword, dst, src, p_align, NULL); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Phdr*)malloc(sizeof(GElf_Phdr)); + if (!dst) { + seterr(ERROR_MEM_PHDR); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_phdr(Elf *elf, int ndx, GElf_Phdr *src) { + char *tmp; + size_t n; + + if (!elf || !src) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + tmp = _elf_getphdr(elf, elf->e_class); + if (!tmp) { + return 0; + } + if (ndx < 0 || ndx >= elf->e_phnum) { + seterr(ERROR_BADINDEX); + return 0; + } + n = _msize(elf->e_class, _elf_version, ELF_T_PHDR); + if (n == 0) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + if (elf->e_class == ELFCLASS64) { + *(Elf64_Phdr*)(tmp + ndx * n) = *src; + } + else if (elf->e_class == ELFCLASS32) { + Elf32_Phdr *dst = (Elf32_Phdr*)(tmp + ndx * n); + + check_and_copy(Elf32_Word, dst, src, p_type, 0); + check_and_copy(Elf32_Off, dst, src, p_offset, 0); + check_and_copy(Elf32_Addr, dst, src, p_vaddr, 0); + check_and_copy(Elf32_Addr, dst, src, p_paddr, 0); + check_and_copy(Elf32_Word, dst, src, p_filesz, 0); + check_and_copy(Elf32_Word, dst, src, p_memsz, 0); + check_and_copy(Elf32_Word, dst, src, p_flags, 0); + check_and_copy(Elf32_Word, dst, src, p_align, 0); + } + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return 0; + } + return 1; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/gelfshdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/gelfshdr.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/gelfshdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,123 ---- + /* + gelfshdr.c - gelf_* translation functions. + Copyright (C) 2000 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: gelfshdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #define check_and_copy(type, d, s, name, eret) \ + do { \ + if (sizeof((d)->name) < sizeof((s)->name) \ + && (type)(s)->name != (s)->name) { \ + seterr(ERROR_BADVALUE); \ + return (eret); \ + } \ + (d)->name = (type)(s)->name; \ + } while (0) + + GElf_Shdr* + gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst) { + GElf_Shdr buf; + + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf); + elf_assert(scn->s_elf->e_magic == ELF_MAGIC); + if (!dst) { + dst = &buf; + } + if (scn->s_elf->e_class == ELFCLASS64) { + *dst = scn->s_shdr64; + } + else if (scn->s_elf->e_class == ELFCLASS32) { + Elf32_Shdr *src = &scn->s_shdr32; + + check_and_copy(GElf_Word, dst, src, sh_name, NULL); + check_and_copy(GElf_Word, dst, src, sh_type, NULL); + check_and_copy(GElf_Xword, dst, src, sh_flags, NULL); + check_and_copy(GElf_Addr, dst, src, sh_addr, NULL); + check_and_copy(GElf_Off, dst, src, sh_offset, NULL); + check_and_copy(GElf_Xword, dst, src, sh_size, NULL); + check_and_copy(GElf_Word, dst, src, sh_link, NULL); + check_and_copy(GElf_Word, dst, src, sh_info, NULL); + check_and_copy(GElf_Xword, dst, src, sh_addralign, NULL); + check_and_copy(GElf_Xword, dst, src, sh_entsize, NULL); + } + else if (valid_class(scn->s_elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Shdr*)malloc(sizeof(GElf_Shdr)); + if (!dst) { + seterr(ERROR_MEM_SHDR); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src) { + if (!scn || !src) { + return 0; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf); + elf_assert(scn->s_elf->e_magic == ELF_MAGIC); + if (scn->s_elf->e_class == ELFCLASS64) { + scn->s_shdr64 = *src; + } + else if (scn->s_elf->e_class == ELFCLASS32) { + Elf32_Shdr *dst = &scn->s_shdr32; + + check_and_copy(Elf32_Word, dst, src, sh_name, 0); + check_and_copy(Elf32_Word, dst, src, sh_type, 0); + check_and_copy(Elf32_Word, dst, src, sh_flags, 0); + check_and_copy(Elf32_Addr, dst, src, sh_addr, 0); + check_and_copy(Elf32_Off, dst, src, sh_offset, 0); + check_and_copy(Elf32_Word, dst, src, sh_size, 0); + check_and_copy(Elf32_Word, dst, src, sh_link, 0); + check_and_copy(Elf32_Word, dst, src, sh_info, 0); + check_and_copy(Elf32_Word, dst, src, sh_addralign, 0); + check_and_copy(Elf32_Word, dst, src, sh_entsize, 0); + } + else if (valid_class(scn->s_elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return 0; + } + return 1; + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/gelftrans.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/gelftrans.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/gelftrans.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,407 ---- + /* + gelftrans.c - gelf_* translation functions. + Copyright (C) 2000 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: gelftrans.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #define check_and_copy(type, d, s, name, eret) \ + do { \ + if (sizeof((d)->name) < sizeof((s)->name) \ + && (type)(s)->name != (s)->name) { \ + seterr(ERROR_BADVALUE); \ + return (eret); \ + } \ + (d)->name = (type)(s)->name; \ + } while (0) + + /* + * These macros are missing on some Linux systems + */ + #if !defined(ELF32_R_SYM) || !defined(ELF32_R_TYPE) || !defined(ELF32_R_INFO) + # undef ELF32_R_SYM + # undef ELF32_R_TYPE + # undef ELF32_R_INFO + # define ELF32_R_SYM(i) ((i)>>8) + # define ELF32_R_TYPE(i) ((unsigned char)(i)) + # define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t)) + #endif /* !defined(...) */ + + #if !defined(ELF64_R_SYM) || !defined(ELF64_R_TYPE) || !defined(ELF64_R_INFO) + # undef ELF64_R_SYM + # undef ELF64_R_TYPE + # undef ELF64_R_INFO + # define ELF64_R_SYM(i) ((i)>>32) + # define ELF64_R_TYPE(i) ((i)&0xffffffffL) + # define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL)) + #endif /* !defined(...) */ + + static char* + get_addr_and_class(const Elf_Data *data, int ndx, Elf_Type type, unsigned *cls) { + Scn_Data *sd = (Scn_Data*)data; + Elf_Scn *scn; + Elf *elf; + size_t n; + + if (!sd) { + return NULL; + } + elf_assert(sd->sd_magic == DATA_MAGIC); + scn = sd->sd_scn; + elf_assert(scn); + elf_assert(scn->s_magic == SCN_MAGIC); + elf = scn->s_elf; + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + return NULL; + } + if (!valid_class(elf->e_class)) { + seterr(ERROR_UNKNOWN_CLASS); + return NULL; + } + if (data->d_type != type) { + seterr(ERROR_BADTYPE); + return NULL; + } + n = _msize(elf->e_class, data->d_version, type); + if (n == 0) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (ndx < 0 || data->d_size < (ndx + 1) * n) { + seterr(ERROR_BADINDEX); + return NULL; + } + if (!data->d_buf) { + seterr(ERROR_NULLBUF); + return NULL; + } + if (cls) { + *cls = elf->e_class; + } + return (char*)data->d_buf + n * ndx; + } + + GElf_Sym* + gelf_getsym(Elf_Data *src, int ndx, GElf_Sym *dst) { + GElf_Sym buf; + unsigned cls; + char *tmp; + + if (!dst) { + dst = &buf; + } + tmp = get_addr_and_class(src, ndx, ELF_T_SYM, &cls); + if (!tmp) { + return NULL; + } + if (cls == ELFCLASS64) { + *dst = *(Elf64_Sym*)tmp; + } + else if (cls == ELFCLASS32) { + Elf32_Sym *src = (Elf32_Sym*)tmp; + + check_and_copy(GElf_Word, dst, src, st_name, NULL); + check_and_copy(unsigned char, dst, src, st_info, NULL); + check_and_copy(unsigned char, dst, src, st_other, NULL); + check_and_copy(GElf_Half, dst, src, st_shndx, NULL); + check_and_copy(GElf_Addr, dst, src, st_value, NULL); + check_and_copy(GElf_Xword, dst, src, st_size, NULL); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Sym*)malloc(sizeof(GElf_Sym)); + if (!dst) { + seterr(ERROR_MEM_SYM); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src) { + unsigned cls; + char *tmp; + + tmp = get_addr_and_class(dst, ndx, ELF_T_SYM, &cls); + if (!tmp) { + return 0; + } + if (cls == ELFCLASS64) { + *(Elf64_Sym*)tmp = *src; + } + else if (cls == ELFCLASS32) { + Elf32_Sym *dst = (Elf32_Sym*)tmp; + + check_and_copy(Elf32_Word, dst, src, st_name, 0); + check_and_copy(Elf32_Addr, dst, src, st_value, 0); + check_and_copy(Elf32_Word, dst, src, st_size, 0); + check_and_copy(unsigned char, dst, src, st_info, 0); + check_and_copy(unsigned char, dst, src, st_other, 0); + check_and_copy(Elf32_Half, dst, src, st_shndx, 0); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + return 1; + } + + GElf_Dyn* + gelf_getdyn(Elf_Data *src, int ndx, GElf_Dyn *dst) { + GElf_Dyn buf; + unsigned cls; + char *tmp; + + if (!dst) { + dst = &buf; + } + tmp = get_addr_and_class(src, ndx, ELF_T_DYN, &cls); + if (!tmp) { + return NULL; + } + if (cls == ELFCLASS64) { + *dst = *(Elf64_Dyn*)tmp; + } + else if (cls == ELFCLASS32) { + Elf32_Dyn *src = (Elf32_Dyn*)tmp; + + check_and_copy(GElf_Sxword, dst, src, d_tag, NULL); + check_and_copy(GElf_Xword, dst, src, d_un.d_val, NULL); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Dyn*)malloc(sizeof(GElf_Dyn)); + if (!dst) { + seterr(ERROR_MEM_DYN); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src) { + unsigned cls; + char *tmp; + + tmp = get_addr_and_class(dst, ndx, ELF_T_DYN, &cls); + if (!tmp) { + return 0; + } + if (cls == ELFCLASS64) { + *(Elf64_Dyn*)tmp = *src; + } + else if (cls == ELFCLASS32) { + Elf32_Dyn *dst = (Elf32_Dyn*)tmp; + + check_and_copy(Elf32_Sword, dst, src, d_tag, 0); + check_and_copy(Elf32_Word, dst, src, d_un.d_val, 0); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + return 1; + } + + GElf_Rela* + gelf_getrela(Elf_Data *src, int ndx, GElf_Rela *dst) { + GElf_Rela buf; + unsigned cls; + char *tmp; + + if (!dst) { + dst = &buf; + } + tmp = get_addr_and_class(src, ndx, ELF_T_RELA, &cls); + if (!tmp) { + return NULL; + } + if (cls == ELFCLASS64) { + *dst = *(Elf64_Rela*)tmp; + } + else if (cls == ELFCLASS32) { + Elf32_Rela *src = (Elf32_Rela*)tmp; + + check_and_copy(GElf_Addr, dst, src, r_offset, NULL); + dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info), + (Elf64_Xword)ELF32_R_TYPE(src->r_info)); + check_and_copy(GElf_Sxword, dst, src, r_addend, NULL); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Rela*)malloc(sizeof(GElf_Rela)); + if (!dst) { + seterr(ERROR_MEM_RELA); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src) { + unsigned cls; + char *tmp; + + tmp = get_addr_and_class(dst, ndx, ELF_T_RELA, &cls); + if (!tmp) { + return 0; + } + if (cls == ELFCLASS64) { + *(Elf64_Rela*)tmp = *src; + } + else if (cls == ELFCLASS32) { + Elf32_Rela *dst = (Elf32_Rela*)tmp; + + check_and_copy(Elf32_Addr, dst, src, r_offset, 0); + if (ELF64_R_SYM(src->r_info) > 0xffffffUL + || ELF64_R_TYPE(src->r_info) > 0xffUL) { + seterr(ERROR_BADVALUE); + return 0; + } + dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info), + (Elf32_Word)ELF64_R_TYPE(src->r_info)); + check_and_copy(Elf32_Sword, dst, src, r_addend, 0); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + return 1; + } + + GElf_Rel* + gelf_getrel(Elf_Data *src, int ndx, GElf_Rel *dst) { + GElf_Rel buf; + unsigned cls; + char *tmp; + + if (!dst) { + dst = &buf; + } + tmp = get_addr_and_class(src, ndx, ELF_T_REL, &cls); + if (!tmp) { + return NULL; + } + if (cls == ELFCLASS64) { + *dst = *(Elf64_Rel*)tmp; + } + else if (cls == ELFCLASS32) { + Elf32_Rel *src = (Elf32_Rel*)tmp; + + check_and_copy(GElf_Addr, dst, src, r_offset, NULL); + dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info), + (Elf64_Xword)ELF32_R_TYPE(src->r_info)); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (dst == &buf) { + dst = (GElf_Rel*)malloc(sizeof(GElf_Rel)); + if (!dst) { + seterr(ERROR_MEM_REL); + return NULL; + } + *dst = buf; + } + return dst; + } + + int + gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src) { + unsigned cls; + char *tmp; + + tmp = get_addr_and_class(dst, ndx, ELF_T_REL, &cls); + if (!tmp) { + return 0; + } + if (cls == ELFCLASS64) { + *(Elf64_Rel*)tmp = *src; + } + else if (cls == ELFCLASS32) { + Elf32_Rel *dst = (Elf32_Rel*)tmp; + + check_and_copy(Elf32_Addr, dst, src, r_offset, 0); + if (ELF64_R_SYM(src->r_info) > 0xffffffUL + || ELF64_R_TYPE(src->r_info) > 0xffUL) { + seterr(ERROR_BADVALUE); + return 0; + } + dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info), + (Elf32_Word)ELF64_R_TYPE(src->r_info)); + } + else { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + return 1; + } + + #if 0 + + GElf_Syminfo* + gelf_getsyminfo(Elf_Data *src, int ndx, GElf_Syminfo *dst) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + + int + gelf_update_syminfo(Elf_Data *dst, int ndx, GElf_Syminfo *src) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + + GElf_Move* + gelf_getmove(Elf_Data *src, int ndx, GElf_Move *src) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + + int + gelf_update_move(Elf_Data *dst, int ndx, GElf_Move *src) { + seterr(ERROR_UNIMPLEMENTED); + return 0; + } + + #endif + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/getarhdr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getarhdr.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getarhdr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,37 ---- + /* + getarhdr.c - implementation of the elf_getarhdr(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getarhdr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Arhdr* + elf_getarhdr(Elf *elf) { + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_arhdr) { + return elf->e_arhdr; + } + seterr(ERROR_NOTARCHIVE); + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/getarsym.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getarsym.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getarsym.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,87 ---- + /* + getarsym.c - implementation of the elf_getarsym(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getarsym.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Arsym* + elf_getarsym(Elf *elf, size_t *ptr) { + Elf_Arsym *syms; + size_t count; + size_t tmp; + size_t i; + char *s; + char *e; + + if (!ptr) { + ptr = &tmp; + } + *ptr = 0; + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_AR) { + seterr(ERROR_NOTARCHIVE); + return NULL; + } + if (elf->e_symtab && !elf->e_free_syms) { + if (elf->e_symlen < 4) { + seterr(ERROR_SIZE_ARSYMTAB); + return NULL; + } + count = __load_u32M(elf->e_symtab); + if (elf->e_symlen < 4 * (count + 1)) { + seterr(ERROR_SIZE_ARSYMTAB); + return NULL; + } + if (!(syms = (Elf_Arsym*)malloc((count + 1) * sizeof(*syms)))) { + seterr(ERROR_MEM_ARSYMTAB); + return NULL; + } + s = elf->e_symtab + 4 * (count + 1); + e = elf->e_symtab + elf->e_symlen; + for (i = 0; i < count; i++, s++) { + syms[i].as_name = s; + while (s < e && *s) { + s++; + } + if (s >= e) { + seterr(ERROR_SIZE_ARSYMTAB); + free(syms); + return NULL; + } + elf_assert(!*s); + syms[i].as_hash = elf_hash(syms[i].as_name); + syms[i].as_off = __load_u32M(elf->e_symtab + 4 * (i + 1)); + } + syms[count].as_name = NULL; + syms[count].as_hash = ~0UL; + syms[count].as_off = 0; + elf->e_symtab = (char*)syms; + elf->e_symlen = count + 1; + elf->e_free_syms = 1; + } + *ptr = elf->e_symlen; + return (Elf_Arsym*)elf->e_symtab; + } Index: llvm/lib/CodeGen/ELF/lib/getbase.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getbase.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getbase.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,33 ---- + /* + getbase.c - implementation of the elf_getbase(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getbase.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + off_t + elf_getbase(Elf *elf) { + if (!elf) { + return -1; + } + elf_assert(elf->e_magic == ELF_MAGIC); + return (off_t)elf->e_base; + } Index: llvm/lib/CodeGen/ELF/lib/getdata.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getdata.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getdata.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,157 ---- + /* + getdata.c - implementation of the elf_getdata(3) function. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getdata.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + static Elf_Data* + _elf_cook_scn(Elf *elf, Elf_Scn *scn, Scn_Data *sd) { + Elf_Data dst; + Elf_Data src; + int flag = 0; + size_t dlen; + + elf_assert(elf->e_data); + + /* + * Prepare source + */ + src = sd->sd_data; + src.d_version = elf->e_version; + if (elf->e_rawdata) { + src.d_buf = elf->e_rawdata + scn->s_offset; + } + else { + src.d_buf = elf->e_data + scn->s_offset; + } + + /* + * Prepare destination (needs prepared source!) + */ + dst = sd->sd_data; + if (elf->e_class == ELFCLASS32) { + dlen = _elf32_xltsize(&src, dst.d_version, elf->e_encoding, 0); + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + dlen = _elf64_xltsize(&src, dst.d_version, elf->e_encoding, 0); + } + #endif /* __LIBELF64 */ + else { + elf_assert(valid_class(elf->e_class)); + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + if (dlen == (size_t)-1) { + return NULL; + } + dst.d_size = dlen; + if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) { + dst.d_buf = elf->e_data + scn->s_offset; + } + else if (!(dst.d_buf = malloc(dst.d_size))) { + seterr(ERROR_MEM_SCNDATA); + return NULL; + } + else { + flag = 1; + } + + /* + * Translate data + */ + if (_elf_xlatetom(elf, &dst, &src)) { + sd->sd_memdata = (char*)dst.d_buf; + sd->sd_data = dst; + if (!(sd->sd_free_data = flag)) { + elf->e_cooked = 1; + } + return &sd->sd_data; + } + + if (flag) { + free(dst.d_buf); + } + return NULL; + } + + Elf_Data* + elf_getdata(Elf_Scn *scn, Elf_Data *data) { + Scn_Data *sd; + Elf *elf; + + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + if (scn->s_index == SHN_UNDEF) { + seterr(ERROR_NULLSCN); + } + else if (data) { + for (sd = scn->s_data_1; sd; sd = sd->sd_link) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (data == &sd->sd_data) { + /* + * sd_link allocated by elf_newdata(). + */ + return &sd->sd_link->sd_data; + } + } + seterr(ERROR_SCNDATAMISMATCH); + } + else if ((sd = scn->s_data_1)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + elf = scn->s_elf; + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + if (sd->sd_freeme) { + /* allocated by elf_newdata() */ + return &sd->sd_data; + } + else if (scn->s_type == SHT_NULL) { + seterr(ERROR_NULLSCN); + } + else if (sd->sd_memdata) { + /* already cooked */ + return &sd->sd_data; + } + else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) { + seterr(ERROR_OUTSIDE); + } + else if (scn->s_type == SHT_NOBITS || !scn->s_size) { + /* no data to read */ + return &sd->sd_data; + } + else if (scn->s_offset + scn->s_size > elf->e_size) { + seterr(ERROR_TRUNC_SCN); + } + else if (valid_class(elf->e_class)) { + return _elf_cook_scn(elf, scn, sd); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/getident.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getident.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getident.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,48 ---- + /* + getident.c - implementation of the elf_getident(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getident.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + char* + elf_getident(Elf *elf, size_t *ptr) { + size_t tmp; + + if (!ptr) { + ptr = &tmp; + } + if (!elf) { + *ptr = 0; + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + *ptr = elf->e_idlen; + return elf->e_data; + } + if (elf->e_ehdr || _elf_cook(elf)) { + *ptr = elf->e_idlen; + return elf->e_ehdr; + } + *ptr = 0; + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/getscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/getscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/getscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,48 ---- + /* + getscn.c - implementation of the elf_getscn(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: getscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Scn* + elf_getscn(Elf *elf, size_t index) { + Elf_Scn *scn; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_ehdr || _elf_cook(elf)) { + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + if (scn->s_index == index) { + return scn; + } + } + seterr(ERROR_NOSUCHSCN); + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/hash.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/hash.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/hash.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,38 ---- + /* + hash.c - implementation of the elf_hash(3) function. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: hash.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + unsigned long + elf_hash(const unsigned char *name) { + unsigned long hash = 0; + unsigned long tmp; + + while (*name) { + hash = (hash << 4) + (unsigned char)*name++; + if ((tmp = hash & 0xf0000000)) { + hash ^= tmp | (tmp >> 24); + } + } + return hash; + } Index: llvm/lib/CodeGen/ELF/lib/input.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/input.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/input.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,81 ---- + /* + input.c - low-level input for libelf. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: input.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_MMAP + #include + #endif /* HAVE_MMAP */ + + void* + _elf_read(Elf *elf, void *buffer, size_t off, size_t len) { + void *tmp; + + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + elf_assert(off >= 0 && off + len <= elf->e_size); + if (elf->e_disabled) { + seterr(ERROR_FDDISABLED); + } + else if (len) { + off += elf->e_base; + if (lseek(elf->e_fd, (off_t)off, SEEK_SET) != (off_t)off) { + seterr(ERROR_IO_SEEK); + } + else if (!(tmp = buffer) && !(tmp = malloc(len))) { + seterr(ERROR_IO_2BIG); + } + else if (read(elf->e_fd, tmp, len) != (int)len) { + seterr(ERROR_IO_READ); + if (tmp != buffer) { + free(tmp); + } + } + else { + return tmp; + } + } + return NULL; + } + + void* + _elf_mmap(Elf *elf) { + #if HAVE_MMAP + void *tmp; + + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + elf_assert(elf->e_base == 0); + if (elf->e_disabled) { + seterr(ERROR_FDDISABLED); + } + else if (elf->e_size) { + tmp = (void*)mmap(0, elf->e_size, PROT_READ | PROT_WRITE, + MAP_PRIVATE, elf->e_fd, 0); + if (tmp != (void*)-1) { + return tmp; + } + } + #endif /* HAVE_MMAP */ + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/kind.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/kind.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/kind.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,33 ---- + /* + kind.c - implementation of the elf_kind(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: kind.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Kind + elf_kind(Elf *elf) { + if (!elf) { + return ELF_K_NONE; + } + elf_assert(elf->e_magic == ELF_MAGIC); + return elf->e_kind; + } Index: llvm/lib/CodeGen/ELF/lib/libelf.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/libelf.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/libelf.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,264 ---- + /* + libelf.h - public header file for libelf. + Copyright (C) 1995 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: libelf.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _LIBELF_H + #define _LIBELF_H + + #include + + #if __LIBELF_INTERNAL__ + #include + #else /* __LIBELF_INTERNAL__ */ + #include + #endif /* __LIBELF_INTERNAL__ */ + + #ifdef __cplusplus + extern "C" { + #endif /* __cplusplus */ + + #ifndef __P + # if __STDC__ || defined(__cplusplus) + # define __P(args) args + # else /* __STDC__ || defined(__cplusplus) */ + # define __P(args) () + # endif /* __STDC__ || defined(__cplusplus) */ + #endif /* __P */ + + /* + * Commands + */ + typedef enum { + ELF_C_NULL = 0, /* must be first, 0 */ + ELF_C_READ, + ELF_C_WRITE, + ELF_C_CLR, + ELF_C_SET, + ELF_C_FDDONE, + ELF_C_FDREAD, + ELF_C_RDWR, + ELF_C_NUM /* must be last */ + } Elf_Cmd; + + /* + * Flags + */ + #define ELF_F_DIRTY 0x1 + #define ELF_F_LAYOUT 0x4 + + /* + * File types + */ + typedef enum { + ELF_K_NONE = 0, /* must be first, 0 */ + ELF_K_AR, + ELF_K_COFF, + ELF_K_ELF, + ELF_K_NUM /* must be last */ + } Elf_Kind; + + /* + * Data types + */ + typedef enum { + ELF_T_BYTE = 0, /* must be first, 0 */ + ELF_T_ADDR, + ELF_T_DYN, + ELF_T_EHDR, + ELF_T_HALF, + ELF_T_OFF, + ELF_T_PHDR, + ELF_T_RELA, + ELF_T_REL, + ELF_T_SHDR, + ELF_T_SWORD, + ELF_T_SYM, + ELF_T_WORD, + /* + * New stuff for 64-bit. + * + * Most implementations add ELF_T_SXWORD after ELF_T_SWORD + * which breaks binary compatibility with earlier versions. + * If this causes problems for you, contact me. + */ + ELF_T_SXWORD, + ELF_T_XWORD, + /* + * Symbol versioning. Sun broke binary compatibility (again!), + * but I won't. + */ + ELF_T_VDEF, + ELF_T_VNEED, + ELF_T_NUM /* must be last */ + } Elf_Type; + + /* + * Elf descriptor + */ + typedef struct Elf Elf; + + /* + * Section descriptor + */ + typedef struct Elf_Scn Elf_Scn; + + /* + * Archive member header + */ + typedef struct { + char* ar_name; + time_t ar_date; + long ar_uid; + long ar_gid; + unsigned long ar_mode; + off_t ar_size; + char* ar_rawname; + } Elf_Arhdr; + + /* + * Archive symbol table + */ + typedef struct { + char* as_name; + size_t as_off; + unsigned long as_hash; + } Elf_Arsym; + + /* + * Data descriptor + */ + typedef struct { + void* d_buf; + Elf_Type d_type; + size_t d_size; + off_t d_off; + size_t d_align; + unsigned d_version; + } Elf_Data; + + /* + * Function declarations + */ + extern Elf *elf_begin __P((int __fd, Elf_Cmd __cmd, Elf *__ref)); + extern Elf *elf_memory __P((char *__image, size_t __size)); + extern int elf_cntl __P((Elf *__elf, Elf_Cmd __cmd)); + extern int elf_end __P((Elf *__elf)); + extern const char *elf_errmsg __P((int __err)); + extern int elf_errno __P((void)); + extern void elf_fill __P((int __fill)); + extern unsigned elf_flagdata __P((Elf_Data *__data, Elf_Cmd __cmd, + unsigned __flags)); + extern unsigned elf_flagehdr __P((Elf *__elf, Elf_Cmd __cmd, + unsigned __flags)); + extern unsigned elf_flagelf __P((Elf *__elf, Elf_Cmd __cmd, + unsigned __flags)); + extern unsigned elf_flagphdr __P((Elf *__elf, Elf_Cmd __cmd, + unsigned __flags)); + extern unsigned elf_flagscn __P((Elf_Scn *__scn, Elf_Cmd __cmd, + unsigned __flags)); + extern unsigned elf_flagshdr __P((Elf_Scn *__scn, Elf_Cmd __cmd, + unsigned __flags)); + extern size_t elf32_fsize __P((Elf_Type __type, size_t __count, + unsigned __ver)); + extern Elf_Arhdr *elf_getarhdr __P((Elf *__elf)); + extern Elf_Arsym *elf_getarsym __P((Elf *__elf, size_t *__ptr)); + extern off_t elf_getbase __P((Elf *__elf)); + extern Elf_Data *elf_getdata __P((Elf_Scn *__scn, Elf_Data *__data)); + extern Elf32_Ehdr *elf32_getehdr __P((Elf *__elf)); + extern char *elf_getident __P((Elf *__elf, size_t *__ptr)); + extern Elf32_Phdr *elf32_getphdr __P((Elf *__elf)); + extern Elf_Scn *elf_getscn __P((Elf *__elf, size_t __index)); + extern Elf32_Shdr *elf32_getshdr __P((Elf_Scn *__scn)); + extern unsigned long elf_hash __P((const unsigned char *__name)); + extern Elf_Kind elf_kind __P((Elf *__elf)); + extern size_t elf_ndxscn __P((Elf_Scn *__scn)); + extern Elf_Data *elf_newdata __P((Elf_Scn *__scn)); + extern Elf32_Ehdr *elf32_newehdr __P((Elf *__elf)); + extern Elf32_Phdr *elf32_newphdr __P((Elf *__elf, size_t __count)); + extern Elf_Scn *elf_newscn __P((Elf *__elf)); + extern Elf_Cmd elf_next __P((Elf *__elf)); + extern Elf_Scn *elf_nextscn __P((Elf *__elf, Elf_Scn *__scn)); + extern size_t elf_rand __P((Elf *__elf, size_t __offset)); + extern Elf_Data *elf_rawdata __P((Elf_Scn *__scn, Elf_Data *__data)); + extern char *elf_rawfile __P((Elf *__elf, size_t *__ptr)); + extern char *elf_strptr __P((Elf *__elf, size_t __section, size_t __offset)); + extern off_t elf_update __P((Elf *__elf, Elf_Cmd __cmd)); + extern unsigned elf_version __P((unsigned __ver)); + extern Elf_Data *elf32_xlatetof __P((Elf_Data *__dst, const Elf_Data *__src, + unsigned __encode)); + extern Elf_Data *elf32_xlatetom __P((Elf_Data *__dst, const Elf_Data *__src, + unsigned __encode)); + + /* + * Additional functions found on Solaris + */ + extern long elf32_checksum __P((Elf *__elf)); + + #if __LIBELF64 + /* + * 64-bit ELF functions + * Not available on all platforms + */ + extern Elf64_Ehdr *elf64_getehdr __P((Elf *__elf)); + extern Elf64_Ehdr *elf64_newehdr __P((Elf *__elf)); + extern Elf64_Phdr *elf64_getphdr __P((Elf *__elf)); + extern Elf64_Phdr *elf64_newphdr __P((Elf *__elf, size_t __count)); + extern Elf64_Shdr *elf64_getshdr __P((Elf_Scn *__scn)); + extern size_t elf64_fsize __P((Elf_Type __type, size_t __count, + unsigned __ver)); + extern Elf_Data *elf64_xlatetof __P((Elf_Data *__dst, const Elf_Data *__src, + unsigned __encode)); + extern Elf_Data *elf64_xlatetom __P((Elf_Data *__dst, const Elf_Data *__src, + unsigned __encode)); + + /* + * Additional functions found on Solaris + */ + extern long elf64_checksum __P((Elf *__elf)); + + #endif /* __LIBELF64 */ + + /* + * Experimental extensions: + * + * elfx_movscn() moves section `__scn' directly after section `__after'. + * elfx_remscn() removes section `__scn'. Both functions update + * the section indices; elfx_remscn() also adjusts the ELF header's + * e_shnum member. The application is responsible for updating other + * data (in particular, e_shstrndx and the section headers' sh_link and + * sh_info members). + * + * elfx_movscn() returns the new index of the moved section. + * elfx_remscn() returns the original index of the removed section. + * A return value of zero indicates an error. + */ + extern size_t elfx_movscn __P((Elf *__elf, Elf_Scn *__scn, Elf_Scn *__after)); + extern size_t elfx_remscn __P((Elf *__elf, Elf_Scn *__scn)); + + /* + * elf_delscn() is obsolete. Please use elfx_remscn() instead. + */ + extern size_t elf_delscn __P((Elf *__elf, Elf_Scn *__scn)); + + #ifdef __cplusplus + } + #endif /* __cplusplus */ + + #endif /* _LIBELF_H */ Index: llvm/lib/CodeGen/ELF/lib/memset.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/memset.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/memset.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,52 ---- + /* + memset.c - replacement for memset(3), using duff's device. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #if HAVE_CONFIG_H + # include + #endif /* HAVE_CONFIG_H */ + + #ifndef lint + static const char rcsid[] = "@(#) $Id: memset.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #include + + void* + _elf_memset(void *s, int c, size_t n) { + char *t = (char*)s; + + if (n) { + switch (n % 8u) { + do { + n -= 8; + default: + case 0: *t++ = (char)c; + case 7: *t++ = (char)c; + case 6: *t++ = (char)c; + case 5: *t++ = (char)c; + case 4: *t++ = (char)c; + case 3: *t++ = (char)c; + case 2: *t++ = (char)c; + case 1: *t++ = (char)c; + } + while (n > 8); + } + } + return s; + } Index: llvm/lib/CodeGen/ELF/lib/ndxscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/ndxscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/ndxscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,33 ---- + /* + ndxscn.c - implementation of the elf_ndxscn(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: ndxscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + size_t + elf_ndxscn(Elf_Scn *scn) { + if (!scn) { + return SHN_UNDEF; + } + elf_assert(scn->s_magic == SCN_MAGIC); + return scn->s_index; + } Index: llvm/lib/CodeGen/ELF/lib/newdata.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/newdata.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/newdata.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,56 ---- + /* + newdata.c - implementation of the elf_newdata(3) function. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: newdata.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Data* + elf_newdata(Elf_Scn *scn) { + Scn_Data *sd; + + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + if (scn->s_index == SHN_UNDEF) { + seterr(ERROR_NULLSCN); + } + else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) { + seterr(ERROR_MEM_SCNDATA); + } + else { + *sd = _elf_data_init; + sd->sd_scn = scn; + sd->sd_data_flags = ELF_F_DIRTY; + sd->sd_freeme = 1; + sd->sd_data.d_version = _elf_version; + if (scn->s_data_n) { + scn->s_data_n->sd_link = sd; + } + else { + scn->s_data_1 = sd; + } + scn->s_data_n = sd; + return &sd->sd_data; + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/newscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/newscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/newscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,120 ---- + /* + newscn.c - implementation of the elf_newscn(3) function. + Copyright (C) 1995 - 1998, 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: newscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + int + _elf_update_shnum(Elf *elf, size_t shnum) { + Elf_Scn *scn; + + if (elf->e_class == ELFCLASS32) { + if (shnum >= SHN_LORESERVE) { + scn = elf->e_scn_1; + elf_assert(scn->s_index == 0); + scn->s_shdr_flags |= ELF_F_DIRTY; + scn->s_shdr32.sh_size = shnum; + shnum = 0; + } + elf->e_ehdr_flags |= ELF_F_DIRTY; + ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = shnum; + return 0; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + if (shnum >= SHN_LORESERVE) { + scn = elf->e_scn_1; + elf_assert(scn->s_index == 0); + scn->s_shdr_flags |= ELF_F_DIRTY; + scn->s_shdr64.sh_size = shnum; + shnum = 0; + } + elf->e_ehdr_flags |= ELF_F_DIRTY; + ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = shnum; + return 0; + } + #endif /* __LIBELF64 */ + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + return -1; + } + + static Elf_Scn* + _buildscn(Elf *elf) { + Elf_Scn *scn; + + elf_assert(elf); + elf_assert(elf->e_ehdr); + elf_assert(_elf_scn_init.s_magic == SCN_MAGIC); + while ((scn = (Elf_Scn*)malloc(sizeof(*scn)))) { + *scn = _elf_scn_init; + scn->s_elf = elf; + scn->s_scn_flags = ELF_F_DIRTY; + scn->s_shdr_flags = ELF_F_DIRTY; + scn->s_freeme = 1; + if (elf->e_scn_n) { + scn->s_index = elf->e_scn_n->s_index + 1; + if (_elf_update_shnum(elf, scn->s_index + 1)) { + free(scn); + return NULL; + } + elf->e_scn_n->s_link = scn; + elf->e_scn_n = scn; + return scn; + } + scn->s_index = 0; + if (_elf_update_shnum(elf, 1)) { + free(scn); + return NULL; + } + elf->e_scn_1 = elf->e_scn_n = scn; + } + seterr(ERROR_MEM_SCN); + return NULL; + } + + Elf_Scn* + elf_newscn(Elf *elf) { + Elf_Scn *scn; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (!elf->e_readable && !elf->e_ehdr) { + seterr(ERROR_NOEHDR); + } + else if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (!elf->e_ehdr && !_elf_cook(elf)) { + return NULL; + } + else if ((scn = _buildscn(elf))) { + return scn; + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/next.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/next.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/next.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,42 ---- + /* + next.c - implementation of the elf_next(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: next.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Cmd + elf_next(Elf *elf) { + if (!elf) { + return ELF_C_NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (!elf->e_parent) { + return ELF_C_NULL; + } + elf_assert(elf->e_parent->e_magic == ELF_MAGIC); + elf_assert(elf->e_parent->e_kind == ELF_K_AR); + elf->e_parent->e_off = elf->e_next; + if (elf->e_next == elf->e_parent->e_size) { + return ELF_C_NULL; + } + return ELF_C_READ; + } Index: llvm/lib/CodeGen/ELF/lib/nextscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/nextscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/nextscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,54 ---- + /* + nextscn.c - implementation of the elf_nextscn(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: nextscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Scn* + elf_nextscn(Elf *elf, Elf_Scn *scn) { + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (scn) { + elf_assert(scn->s_magic == SCN_MAGIC); + if (scn->s_elf == elf) { + return scn->s_link; + } + seterr(ERROR_ELFSCNMISMATCH); + } + else if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_ehdr || _elf_cook(elf)) { + elf_assert(elf->e_ehdr); + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + if (scn->s_index == 1) { + return scn; + } + } + seterr(ERROR_NOSUCHSCN); + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/nlist.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/nlist.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/nlist.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,249 ---- + /* + nlist.c - implementation of the nlist(3) function. + Copyright (C) 1995 - 2002 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: nlist.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_FCNTL_H + #include + #endif /* HAVE_FCNTL_H */ + + #ifndef O_RDONLY + #define O_RDONLY 0 + #endif /* O_RDONLY */ + + #ifndef O_BINARY + #define O_BINARY 0 + #endif /* O_BINARY */ + + #define FILE_OPEN_MODE (O_RDONLY | O_BINARY) + + #define PRIME 217 + + struct hash { + const char* name; + unsigned long hash; + unsigned next; + }; + + static const char* + symbol_name(Elf *elf, const void *syms, const char *names, size_t nlimit, size_t index) { + size_t off; + + if (elf->e_class == ELFCLASS32) { + off = ((Elf32_Sym*)syms)[index].st_name; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + off = ((Elf64_Sym*)syms)[index].st_name; + } + #endif /* __LIBELF64 */ + else { + return NULL; + } + if (off >= 0 && off < nlimit) { + return &names[off]; + } + return NULL; + } + + static void + copy_symbol(Elf *elf, struct nlist *np, const void *syms, size_t index) { + if (elf->e_class == ELFCLASS32) { + np->n_value = ((Elf32_Sym*)syms)[index].st_value; + np->n_scnum = ((Elf32_Sym*)syms)[index].st_shndx; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + np->n_value = ((Elf64_Sym*)syms)[index].st_value; + np->n_scnum = ((Elf64_Sym*)syms)[index].st_shndx; + } + #endif /* __LIBELF64 */ + /* + * this needs more work + */ + np->n_type = 0; + np->n_sclass = 0; + np->n_numaux = 0; + } + + static int + _elf_nlist(Elf *elf, struct nlist *nl) { + unsigned first[PRIME]; + Elf_Scn *symtab = NULL; + Elf_Scn *strtab = NULL; + Elf_Data *symdata; + Elf_Data *strdata; + size_t symsize; + size_t nsymbols; + const char *name; + struct hash *table; + unsigned long hash; + unsigned i; + struct nlist *np; + + /* + * Get and translate ELF header, section table and so on. + * Must be class independent, so don't use elf32_get*(). + */ + if (elf->e_kind != ELF_K_ELF) { + return -1; + } + if (!elf->e_ehdr && !_elf_cook(elf)) { + return -1; + } + + /* + * Find symbol table. If there is none, try dynamic symbols. + */ + for (symtab = elf->e_scn_1; symtab; symtab = symtab->s_link) { + if (symtab->s_type == SHT_SYMTAB) { + break; + } + if (symtab->s_type == SHT_DYNSYM) { + strtab = symtab; + } + } + if (!symtab && !(symtab = strtab)) { + return -1; + } + + /* + * Get associated string table. + */ + i = 0; + if (elf->e_class == ELFCLASS32) { + i = symtab->s_shdr32.sh_link; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + i = symtab->s_shdr64.sh_link; + } + #endif /* __LIBELF64 */ + if (i == 0) { + return -1; + } + for (strtab = elf->e_scn_1; strtab; strtab = strtab->s_link) { + if (strtab->s_index == i) { + break; + } + } + if (!strtab || strtab->s_type != SHT_STRTAB) { + return -1; + } + + /* + * Get and translate section data. + */ + symdata = elf_getdata(symtab, NULL); + strdata = elf_getdata(strtab, NULL); + if (!symdata || !strdata) { + return -1; + } + symsize = _msize(elf->e_class, _elf_version, ELF_T_SYM); + elf_assert(symsize); + nsymbols = symdata->d_size / symsize; + if (!symdata->d_buf || !strdata->d_buf || !nsymbols || !strdata->d_size) { + return -1; + } + + /* + * Build a simple hash table. + */ + if (!(table = (struct hash*)malloc(nsymbols * sizeof(*table)))) { + return -1; + } + for (i = 0; i < PRIME; i++) { + first[i] = 0; + } + for (i = 0; i < nsymbols; i++) { + table[i].name = NULL; + table[i].hash = 0; + table[i].next = 0; + } + for (i = 1; i < nsymbols; i++) { + name = symbol_name(elf, symdata->d_buf, strdata->d_buf, + strdata->d_size, i); + if (name == NULL) { + free(table); + return -1; + } + if (*name != '\0') { + table[i].name = name; + table[i].hash = elf_hash(name); + hash = table[i].hash % PRIME; + table[i].next = first[hash]; + first[hash] = i; + } + } + + /* + * Lookup symbols, one by one. + */ + for (np = nl; (name = np->n_name) && *name; np++) { + hash = elf_hash(name); + for (i = first[hash % PRIME]; i; i = table[i].next) { + if (table[i].hash == hash && !strcmp(table[i].name, name)) { + break; + } + } + if (i) { + copy_symbol(elf, np, symdata->d_buf, i); + } + else { + np->n_value = 0; + np->n_scnum = 0; + np->n_type = 0; + np->n_sclass = 0; + np->n_numaux = 0; + } + } + free(table); + return 0; + } + + int + nlist(const char *filename, struct nlist *nl) { + int result = -1; + unsigned oldver; + Elf *elf; + int fd; + + if ((oldver = elf_version(EV_CURRENT)) != EV_NONE) { + if ((fd = open(filename, FILE_OPEN_MODE)) != -1) { + if ((elf = elf_begin(fd, ELF_C_READ, NULL))) { + result = _elf_nlist(elf, nl); + elf_end(elf); + } + close(fd); + } + elf_version(oldver); + } + if (result) { + while (nl->n_name && *nl->n_name) { + nl->n_value = 0; + nl++; + } + } + return result; + } Index: llvm/lib/CodeGen/ELF/lib/nlist.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/nlist.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/nlist.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,48 ---- + /* + nlist.h - public header file for nlist(3). + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: nlist.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _NLIST_H + #define _NLIST_H + + #ifdef __cplusplus + extern "C" { + #endif /* __cplusplus */ + + struct nlist { + char* n_name; + long n_value; + short n_scnum; + unsigned short n_type; + char n_sclass; + char n_numaux; + }; + + #if __STDC__ || defined(__cplusplus) + extern int nlist(const char *__filename, struct nlist *__nl); + #else /* __STDC__ || defined(__cplusplus) */ + extern int nlist(); + #endif /* __STDC__ || defined(__cplusplus) */ + + #ifdef __cplusplus + } + #endif /* __cplusplus */ + + #endif /* _NLIST_H */ Index: llvm/lib/CodeGen/ELF/lib/opt.delscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/opt.delscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/opt.delscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,205 ---- + /* + opt.delscn.c - implementation of the elf_delscn(3) function. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: opt.delscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + static size_t + _newindex(size_t old, size_t index) { + return old == index ? SHN_UNDEF : (old > index ? old - 1 : old); + } + + static void + _elf32_update_shdr(Elf *elf, size_t index) { + Elf32_Shdr *shdr; + Elf_Scn *scn; + + ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1; + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + shdr = &scn->s_shdr32; + switch (shdr->sh_type) { + case SHT_REL: + case SHT_RELA: + shdr->sh_info = _newindex(shdr->sh_info, index); + /* fall through */ + case SHT_DYNSYM: + case SHT_DYNAMIC: + case SHT_HASH: + case SHT_SYMTAB: + #if __LIBELF_SYMBOL_VERSIONS + #if __LIBELF_SUN_SYMBOL_VERSIONS + case SHT_SUNW_verdef: + case SHT_SUNW_verneed: + case SHT_SUNW_versym: + #else /* __LIBELF_SUN_SYMBOL_VERSIONS */ + case SHT_GNU_verdef: + case SHT_GNU_verneed: + case SHT_GNU_versym: + #endif /* __LIBELF_SUN_SYMBOL_VERSIONS */ + #endif /* __LIBELF_SYMBOL_VERSIONS */ + shdr->sh_link = _newindex(shdr->sh_link, index); + /* fall through */ + default: + break; + } + } + } + + #if __LIBELF64 + + static void + _elf64_update_shdr(Elf *elf, size_t index) { + Elf64_Shdr *shdr; + Elf_Scn *scn; + + ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1; + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + shdr = &scn->s_shdr64; + switch (shdr->sh_type) { + case SHT_REL: + case SHT_RELA: + shdr->sh_info = _newindex(shdr->sh_info, index); + /* fall through */ + case SHT_DYNSYM: + case SHT_DYNAMIC: + case SHT_HASH: + case SHT_SYMTAB: + #if __LIBELF_SYMBOL_VERSIONS + #if __LIBELF_SUN_SYMBOL_VERSIONS + case SHT_SUNW_verdef: + case SHT_SUNW_verneed: + case SHT_SUNW_versym: + #else /* __LIBELF_SUN_SYMBOL_VERSIONS */ + case SHT_GNU_verdef: + case SHT_GNU_verneed: + case SHT_GNU_versym: + #endif /* __LIBELF_SUN_SYMBOL_VERSIONS */ + #endif /* __LIBELF_SYMBOL_VERSIONS */ + shdr->sh_link = _newindex(shdr->sh_link, index); + /* fall through */ + default: + break; + } + } + } + + #endif /* __LIBELF64 */ + + size_t + elf_delscn(Elf *elf, Elf_Scn *scn) { + Elf_Scn *pscn; + Scn_Data *sd; + Scn_Data *tmp; + size_t index; + + if (!elf || !scn) { + return SHN_UNDEF; + } + elf_assert(elf->e_magic == ELF_MAGIC); + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(elf->e_ehdr); + if (scn->s_elf != elf) { + seterr(ERROR_ELFSCNMISMATCH); + return SHN_UNDEF; + } + elf_assert(elf->e_scn_1); + if (scn == elf->e_scn_1) { + seterr(ERROR_NULLSCN); + return SHN_UNDEF; + } + + /* + * Find previous section. + */ + for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) { + if (pscn->s_link == scn) { + break; + } + } + if (pscn->s_link != scn) { + seterr(ERROR_ELFSCNMISMATCH); + return SHN_UNDEF; + } + /* + * Unlink section. + */ + if (elf->e_scn_n == scn) { + elf->e_scn_n = pscn; + } + pscn->s_link = scn->s_link; + index = scn->s_index; + /* + * Free section descriptor and data. + */ + for (sd = scn->s_data_1; sd; sd = tmp) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + tmp = sd->sd_link; + if (sd->sd_free_data && sd->sd_memdata) { + free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if ((sd = scn->s_rawdata)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (sd->sd_free_data && sd->sd_memdata) { + free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if (scn->s_freeme) { + elf_assert(scn->s_index > 0); + free(scn); + } + /* + * Adjust section indices. + */ + for (scn = pscn->s_link; scn; scn = scn->s_link) { + elf_assert(scn->s_index > index); + scn->s_index--; + } + /* + * Adjust ELF header and well-known section headers. + */ + if (elf->e_class == ELFCLASS32) { + _elf32_update_shdr(elf, index); + return index; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + _elf64_update_shdr(elf, index); + return index; + } + #endif /* __LIBELF64 */ + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + return SHN_UNDEF; + } Index: llvm/lib/CodeGen/ELF/lib/private.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/private.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/private.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,399 ---- + /* + private.h - private definitions for libelf. + Copyright (C) 1995 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: private.h,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + #ifndef _PRIVATE_H + #define _PRIVATE_H + + #define __LIBELF_INTERNAL__ 1 + + #if HAVE_CONFIG_H + # include + #endif /* HAVE_CONFIG_H */ + + #include + + #if STDC_HEADERS + # include + # include + #else /* STDC_HEADERS */ + extern void *malloc(), *realloc(); + extern void free(), bcopy(), abort(); + extern int strcmp(), strncmp(), memcmp(); + extern void *memcpy(), *memmove(), *memset(); + #endif /* STDC_HEADERS */ + + #if HAVE_UNISTD_H + # include + #else /* HAVE_UNISTD_H */ + extern int read(), write(), close(); + extern off_t lseek(); + #if HAVE_FTRUNCATE + extern int ftruncate(); + #endif /* HAVE_FTRUNCATE */ + #endif /* HAVE_UNISTD_H */ + + #ifndef SEEK_SET + #define SEEK_SET 0 + #endif /* SEEK_SET */ + #ifndef SEEK_CUR + #define SEEK_CUR 1 + #endif /* SEEK_CUR */ + #ifndef SEEK_END + #define SEEK_END 2 + #endif /* SEEK_END */ + + #if !HAVE_MEMCMP + # define memcmp strncmp + #endif /* !HAVE_MEMCMP */ + #if !HAVE_MEMCPY + # define memcpy(d,s,n) bcopy(s,d,n) + #endif /* !HAVE_MEMCPY */ + #if !HAVE_MEMMOVE + # define memmove(d,s,n) bcopy(s,d,n) + #endif /* !HAVE_MEMMOVE */ + + #if !HAVE_MEMSET + # define memset _elf_memset + extern void *_elf_memset(); + #endif /* !HAVE_MEMSET */ + + #if HAVE_STRUCT_NLIST_DECLARATION + # define nlist __override_nlist_declaration + #endif /* HAVE_STRUCT_NLIST_DECLARATION */ + + #if __LIBELF_NEED_LINK_H + # include + #endif /* __LIBELF_NEED_LINK_H */ + + #include + + #if HAVE_STRUCT_NLIST_DECLARATION + # undef nlist + #endif /* HAVE_STRUCT_NLIST_DECLARATION */ + + #if __LIBELF64 + #include + #endif /* __LIBELF64 */ + + typedef struct Scn_Data Scn_Data; + + /* + * ELF descriptor + */ + struct Elf { + /* common */ + size_t e_size; /* file/member size */ + size_t e_dsize; /* size of memory image */ + Elf_Kind e_kind; /* kind of file */ + char* e_data; /* file/member data */ + char* e_rawdata; /* file/member raw data */ + size_t e_idlen; /* identifier size */ + int e_fd; /* file descriptor */ + unsigned e_count; /* activation count */ + /* archive members (still common) */ + Elf* e_parent; /* NULL if not an archive member */ + size_t e_next; /* 0 if not an archive member */ + size_t e_base; /* 0 if not an archive member */ + Elf* e_link; /* next archive member or NULL */ + Elf_Arhdr* e_arhdr; /* archive member header or NULL */ + /* archives */ + size_t e_off; /* current member offset (for elf_begin) */ + Elf* e_members; /* linked list of active archive members */ + char* e_symtab; /* archive symbol table */ + size_t e_symlen; /* length of archive symbol table */ + char* e_strtab; /* archive string table */ + size_t e_strlen; /* length of archive string table */ + /* ELF files */ + unsigned e_class; /* ELF class */ + unsigned e_encoding; /* ELF data encoding */ + unsigned e_version; /* ELF version */ + char* e_ehdr; /* ELF header */ + char* e_phdr; /* ELF program header table */ + size_t e_phnum; /* size of program header table */ + Elf_Scn* e_scn_1; /* first section */ + Elf_Scn* e_scn_n; /* last section */ + unsigned e_elf_flags; /* elf flags (ELF_F_*) */ + unsigned e_ehdr_flags; /* ehdr flags (ELF_F_*) */ + unsigned e_phdr_flags; /* phdr flags (ELF_F_*) */ + /* misc flags */ + unsigned e_readable : 1; /* file is readable */ + unsigned e_writable : 1; /* file is writable */ + unsigned e_disabled : 1; /* e_fd has been disabled */ + unsigned e_cooked : 1; /* e_data was modified */ + unsigned e_free_syms : 1; /* e_symtab is malloc'ed */ + unsigned e_free_ehdr : 1; /* e_ehdr is malloc'ed */ + unsigned e_free_phdr : 1; /* e_phdr is malloc'ed */ + unsigned e_unmap_data : 1; /* e_data is mmap'ed */ + unsigned e_memory : 1; /* created by elf_memory() */ + /* magic number for debugging */ + long e_magic; + }; + + #define ELF_MAGIC 0x012b649e + + #define INIT_ELF {\ + /* e_size */ 0,\ + /* e_dsize */ 0,\ + /* e_kind */ ELF_K_NONE,\ + /* e_data */ NULL,\ + /* e_rawdata */ NULL,\ + /* e_idlen */ 0,\ + /* e_fd */ -1,\ + /* e_count */ 1,\ + /* e_parent */ NULL,\ + /* e_next */ 0,\ + /* e_base */ 0,\ + /* e_link */ NULL,\ + /* e_arhdr */ NULL,\ + /* e_off */ 0,\ + /* e_members */ NULL,\ + /* e_symtab */ NULL,\ + /* e_symlen */ 0,\ + /* e_strtab */ NULL,\ + /* e_strlen */ 0,\ + /* e_class */ ELFCLASSNONE,\ + /* e_encoding */ ELFDATANONE,\ + /* e_version */ EV_NONE,\ + /* e_ehdr */ NULL,\ + /* e_phdr */ NULL,\ + /* e_phnum */ 0,\ + /* e_scn_1 */ NULL,\ + /* e_scn_n */ NULL,\ + /* e_elf_flags */ 0,\ + /* e_ehdr_flags */ 0,\ + /* e_phdr_flags */ 0,\ + /* e_readable */ 0,\ + /* e_writable */ 0,\ + /* e_disabled */ 0,\ + /* e_cooked */ 0,\ + /* e_free_syms */ 0,\ + /* e_free_ehdr */ 0,\ + /* e_free_phdr */ 0,\ + /* e_unmap_data */ 0,\ + /* e_memory */ 0,\ + /* e_magic */ ELF_MAGIC\ + } + + /* + * Section descriptor + */ + struct Elf_Scn { + Elf_Scn* s_link; /* pointer to next Elf_Scn */ + Elf* s_elf; /* pointer to elf descriptor */ + size_t s_index; /* number of this section */ + unsigned s_scn_flags; /* section flags (ELF_F_*) */ + unsigned s_shdr_flags; /* shdr flags (ELF_F_*) */ + Scn_Data* s_data_1; /* first data buffer */ + Scn_Data* s_data_n; /* last data buffer */ + Scn_Data* s_rawdata; /* raw data buffer */ + /* data copied from shdr */ + unsigned s_type; /* section type */ + size_t s_offset; /* section offset */ + size_t s_size; /* section size */ + /* misc flags */ + unsigned s_freeme : 1; /* this Elf_Scn was malloc'ed */ + /* section header */ + union { + #if __LIBELF64 + Elf64_Shdr u_shdr64; + #endif /* __LIBELF64 */ + Elf32_Shdr u_shdr32; + } s_uhdr; + /* magic number for debugging */ + long s_magic; + }; + #define s_shdr32 s_uhdr.u_shdr32 + #define s_shdr64 s_uhdr.u_shdr64 + + #define SCN_MAGIC 0x012c747d + + #define INIT_SCN {\ + /* s_link */ NULL,\ + /* s_elf */ NULL,\ + /* s_index */ 0,\ + /* s_scn_flags */ 0,\ + /* s_shdr_flags */ 0,\ + /* s_data_1 */ NULL,\ + /* s_data_n */ NULL,\ + /* s_rawdata */ NULL,\ + /* s_type */ SHT_NULL,\ + /* s_offset */ 0,\ + /* s_size */ 0,\ + /* s_freeme */ 0,\ + /* s_uhdr */ {{0,}},\ + /* s_magic */ SCN_MAGIC\ + } + + /* + * Data descriptor + */ + struct Scn_Data { + Elf_Data sd_data; /* must be first! */ + Scn_Data* sd_link; /* pointer to next Scn_Data */ + Elf_Scn* sd_scn; /* pointer to section */ + char* sd_memdata; /* memory image of section */ + unsigned sd_data_flags; /* data flags (ELF_F_*) */ + /* misc flags */ + unsigned sd_freeme : 1; /* this Scn_Data was malloc'ed */ + unsigned sd_free_data : 1; /* sd_memdata is malloc'ed */ + /* magic number for debugging */ + long sd_magic; + }; + + #define DATA_MAGIC 0x01072639 + + #define INIT_DATA {\ + {\ + /* d_buf */ NULL,\ + /* d_type */ ELF_T_BYTE,\ + /* d_size */ 0,\ + /* d_off */ 0,\ + /* d_align */ 0,\ + /* d_version */ EV_NONE\ + },\ + /* sd_link */ NULL,\ + /* sd_scn */ NULL,\ + /* sd_memdata */ NULL,\ + /* sd_data_flags */ 0,\ + /* sd_freeme */ 0,\ + /* sd_free_data */ 0,\ + /* sd_magic */ DATA_MAGIC\ + } + + /* + * Private status variables + */ + extern unsigned _elf_version; + extern int _elf_errno; + extern int _elf_fill; + + /* + * Private functions + */ + extern void *_elf_read __P((Elf*, void*, size_t, size_t)); + extern void *_elf_mmap __P((Elf*)); + extern int _elf_cook __P((Elf*)); + extern char *_elf_getehdr __P((Elf*, unsigned)); + extern char *_elf_getphdr __P((Elf*, unsigned)); + extern Elf_Data *_elf_xlatetom __P((const Elf*, Elf_Data*, const Elf_Data*)); + extern Elf_Type _elf_scn_type __P((unsigned)); + extern size_t _elf32_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof)); + extern size_t _elf64_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof)); + extern int _elf_update_shnum(Elf *__elf, size_t __shnum); + + /* + * Special translators + */ + extern size_t _elf_verdef_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verdef_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n)); + extern size_t _elf_verneed_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n)); + + /* + * Private data + */ + extern const Elf_Scn _elf_scn_init; + extern const Scn_Data _elf_data_init; + extern const size_t _elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2]; + + /* + * Access macros for _elf_fmsize[] + */ + #define _fmsize(c,v,t,w) \ + (_elf_fmsize[(c)-ELFCLASS32][(v)-EV_NONE-1][(t)-ELF_T_BYTE][(w)]) + #define _fsize(c,v,t) _fmsize((c),(v),(t),1) + #define _msize(c,v,t) _fmsize((c),(v),(t),0) + + /* + * Various checks + */ + #define valid_class(c) ((c) >= ELFCLASS32 && (c) <= ELFCLASS64) + #define valid_encoding(e) ((e) >= ELFDATA2LSB && (e) <= ELFDATA2MSB) + #define valid_version(v) ((v) > EV_NONE && (v) <= EV_CURRENT) + #define valid_type(t) ((t) >= ELF_T_BYTE && (t) < ELF_T_NUM) + + /* + * Error codes + */ + enum { + #define __err__(a,b) a, + #include /* include constants from errors.h */ + #undef __err__ + ERROR_NUM + }; + + #define seterr(err) (_elf_errno = (err)) + + /* + * Sizes of data types (external representation) + * These definitions should be in , but... + */ + #ifndef ELF32_FSZ_ADDR + # define ELF32_FSZ_ADDR 4 + # define ELF32_FSZ_HALF 2 + # define ELF32_FSZ_OFF 4 + # define ELF32_FSZ_SWORD 4 + # define ELF32_FSZ_WORD 4 + #endif /* ELF32_FSZ_ADDR */ + #ifndef ELF64_FSZ_ADDR + # define ELF64_FSZ_ADDR 8 + # define ELF64_FSZ_HALF 2 + # define ELF64_FSZ_OFF 8 + # define ELF64_FSZ_SWORD 4 + # define ELF64_FSZ_SXWORD 8 + # define ELF64_FSZ_WORD 4 + # define ELF64_FSZ_XWORD 8 + #endif /* ELF64_FSZ_ADDR */ + + /* + * More missing pieces, in no particular order + */ + #ifndef SHT_SYMTAB_SHNDX + #define SHT_SYMTAB_SHNDX 18 + #endif + + /* + * Debugging + */ + #if ENABLE_DEBUG + extern void __elf_assert __P((const char*, unsigned, const char*)); + # if __STDC__ + # define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,#x);}while(0) + # else /* __STDC__ */ + # define elf_assert(x) do{if(!(x))__elf_assert(__FILE__,__LINE__,"x");}while(0) + # endif /* __STDC__ */ + #else /* ENABLE_DEBUG */ + # define elf_assert(x) do{}while(0) + #endif /* ENABLE_DEBUG */ + + #endif /* _PRIVATE_H */ Index: llvm/lib/CodeGen/ELF/lib/rand.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/rand.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/rand.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,43 ---- + /* + rand.c - implementation of the elf_rand(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: rand.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + size_t + elf_rand(Elf *elf, size_t offset) { + if (!elf) { + return 0; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_AR) { + seterr(ERROR_NOTARCHIVE); + } + else if (offset <= 0 || offset > elf->e_size) { + seterr(ERROR_BADOFF); + } + else { + elf->e_off = offset; + return offset; + } + return 0; + } Index: llvm/lib/CodeGen/ELF/lib/rawdata.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/rawdata.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/rawdata.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,89 ---- + /* + rawdata.c - implementation of the elf_rawdata(3) function. + Copyright (C) 1995 - 2000 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: rawdata.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + Elf_Data* + elf_rawdata(Elf_Scn *scn, Elf_Data *data) { + Scn_Data *sd; + Elf *elf; + + if (!scn) { + return NULL; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf = scn->s_elf; + elf_assert(elf); + elf_assert(elf->e_magic == ELF_MAGIC); + if (!elf->e_readable) { + return NULL; + } + else if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) { + seterr(ERROR_NULLSCN); + } + else if (data) { + return NULL; + } + else if ((sd = scn->s_rawdata)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + return &sd->sd_data; + } + else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) { + seterr(ERROR_OUTSIDE); + } + else if (scn->s_type != SHT_NOBITS + && scn->s_offset + scn->s_size > elf->e_size) { + seterr(ERROR_TRUNC_SCN); + } + else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) { + seterr(ERROR_MEM_SCNDATA); + } + else { + *sd = _elf_data_init; + sd->sd_scn = scn; + sd->sd_freeme = 1; + sd->sd_data.d_size = scn->s_size; + sd->sd_data.d_version = _elf_version; + if (scn->s_type != SHT_NOBITS && scn->s_size) { + if (!(sd->sd_memdata = (char*)malloc(scn->s_size))) { + seterr(ERROR_IO_2BIG); + free(sd); + return NULL; + } + else if (elf->e_rawdata) { + memcpy(sd->sd_memdata, elf->e_rawdata + scn->s_offset, scn->s_size); + } + else if (!_elf_read(elf, sd->sd_memdata, scn->s_offset, scn->s_size)) { + free(sd->sd_memdata); + free(sd); + return NULL; + } + sd->sd_data.d_buf = sd->sd_memdata; + sd->sd_free_data = 1; + } + scn->s_rawdata = sd; + return &sd->sd_data; + } + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/rawfile.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/rawfile.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/rawfile.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,52 ---- + /* + rawfile.c - implementation of the elf_rawfile(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: rawfile.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + char* + elf_rawfile(Elf *elf, size_t *ptr) { + size_t tmp; + + if (!ptr) { + ptr = &tmp; + } + *ptr = 0; + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (!elf->e_readable) { + return NULL; + } + else if (elf->e_size && !elf->e_rawdata) { + elf_assert(elf->e_data); + if (!elf->e_cooked) { + elf->e_rawdata = elf->e_data; + } + else if (!(elf->e_rawdata = _elf_read(elf, NULL, 0, elf->e_size))) { + return NULL; + } + *ptr = elf->e_size; + } + return elf->e_rawdata; + } Index: llvm/lib/CodeGen/ELF/lib/strptr.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/strptr.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/strptr.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,144 ---- + /* + strptr.c - implementation of the elf_strptr(3) function. + Copyright (C) 1995 - 2000, 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: strptr.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + char* + elf_strptr(Elf *elf, size_t section, size_t offset) { + Elf_Data *data; + Elf_Scn *scn; + size_t n; + char *s; + + if (!elf) { + return NULL; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (!(scn = elf_getscn(elf, section))) { + return NULL; + } + if (scn->s_index == SHN_UNDEF) { + seterr(ERROR_NOSTRTAB); + return NULL; + } + /* + * checking the section header is more appropriate + */ + if (elf->e_class == ELFCLASS32) { + if (scn->s_shdr32.sh_type != SHT_STRTAB) { + seterr(ERROR_NOSTRTAB); + return NULL; + } + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + if (scn->s_shdr64.sh_type != SHT_STRTAB) { + seterr(ERROR_NOSTRTAB); + return NULL; + } + } + #endif /* __LIBELF64 */ + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + return NULL; + } + else { + seterr(ERROR_UNKNOWN_CLASS); + return NULL; + } + /* + * Find matching buffer + */ + n = 0; + data = NULL; + if (elf->e_elf_flags & ELF_F_LAYOUT) { + /* + * Programmer is responsible for d_off + * Note: buffers may be in any order! + */ + while ((data = elf_getdata(scn, data))) { + n = data->d_off; + if (offset >= n && offset - n < data->d_size) { + /* + * Found it + */ + break; + } + } + } + else { + /* + * Calculate offsets myself + */ + while ((data = elf_getdata(scn, data))) { + if (data->d_align > 1) { + n += data->d_align - 1; + n -= n % data->d_align; + } + if (offset < n) { + /* + * Invalid offset: points into a hole + */ + seterr(ERROR_BADSTROFF); + return NULL; + } + if (offset - n < data->d_size) { + /* + * Found it + */ + break; + } + n += data->d_size; + } + } + if (data == NULL) { + /* + * Not found + */ + seterr(ERROR_BADSTROFF); + return NULL; + } + if (data->d_buf == NULL) { + /* + * Buffer is NULL (usually the programmers' fault) + */ + seterr(ERROR_NULLBUF); + return NULL; + } + offset -= n; + s = (char*)data->d_buf; + for (n = offset; n < data->d_size; n++) { + if (s[n] == '\0') { + /* + * Return properly NUL terminated string + */ + return s + offset; + } + } + /* + * String is not NUL terminated + * Return error to avoid SEGV in application + */ + seterr(ERROR_UNTERM); + return NULL; + } Index: llvm/lib/CodeGen/ELF/lib/swap64.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/swap64.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/swap64.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,81 ---- + /* + swap64.c - 64-bit byte swapping functions. + Copyright (C) 1995 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + + #if __LIBELF64 + + #ifndef lint + static const char rcsid[] = "@(#) $Id: swap64.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + __libelf_u64_t + _elf_load_u64L(const unsigned char *from) { + return ((__libelf_u64_t)__load_u32L(from + 4) << 32) + | (__libelf_u64_t)__load_u32L(from); + } + + __libelf_u64_t + _elf_load_u64M(const unsigned char *from) { + return ((__libelf_u64_t)__load_u32M(from) << 32) + | (__libelf_u64_t)__load_u32M(from + 4); + } + + __libelf_i64_t + _elf_load_i64L(const unsigned char *from) { + return ((__libelf_i64_t)__load_i32L(from + 4) << 32) + | (__libelf_u64_t)__load_u32L(from); + } + + __libelf_i64_t + _elf_load_i64M(const unsigned char *from) { + return ((__libelf_i64_t)__load_i32M(from) << 32) + | (__libelf_u64_t)__load_u32M(from + 4); + } + + void + _elf_store_u64L(unsigned char *to, __libelf_u64_t v) { + __store_u32L(to, (__libelf_u32_t)v); + v >>= 32; + __store_u32L(to + 4, (__libelf_u32_t)v); + } + + void + _elf_store_u64M(unsigned char *to, __libelf_u64_t v) { + __store_u32M(to + 4, (__libelf_u32_t)v); + v >>= 32; + __store_u32M(to, (__libelf_u32_t)v); + } + + void + _elf_store_i64L(unsigned char *to, __libelf_u64_t v) { + __store_u32L(to, (__libelf_u32_t)v); + v >>= 32; + __store_i32L(to + 4, (__libelf_u32_t)v); + } + + void + _elf_store_i64M(unsigned char *to, __libelf_u64_t v) { + __store_u32M(to + 4, (__libelf_u32_t)v); + v >>= 32; + __store_i32M(to, (__libelf_u32_t)v); + } + + #endif /* __LIBELF64 */ Index: llvm/lib/CodeGen/ELF/lib/sys_elf.h.in diff -c /dev/null llvm/lib/CodeGen/ELF/lib/sys_elf.h.in:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/sys_elf.h.in Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,127 ---- + /* + sys_elf.h.in - configure template for private "switch" file. + Copyright (C) 1998 - 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + /* @(#) $Id: sys_elf.h.in,v 1.1 2005/06/22 06:35:57 reid Exp $ */ + + /* + * DO NOT USE THIS IN APPLICATIONS - #include INSTEAD! + */ + + /* Define to `' or `' if one of them is present */ + #undef __LIBELF_HEADER_ELF_H + + /* Define if Elf32_Dyn is declared in */ + #undef __LIBELF_NEED_LINK_H + + /* Define if you want 64-bit support (and your system supports it) */ + #undef __LIBELF64 + + /* Define if you want 64-bit support, and are running IRIX */ + #undef __LIBELF64_IRIX + + /* Define if you want 64-bit support, and are running Linux */ + #undef __LIBELF64_LINUX + + /* Define if you want symbol versioning (and your system supports it) */ + #undef __LIBELF_SYMBOL_VERSIONS + + /* Define to a 64-bit signed integer type if one exists */ + #undef __libelf_i64_t + + /* Define to a 64-bit unsigned integer type if one exists */ + #undef __libelf_u64_t + + /* Define to a 32-bit signed integer type if one exists */ + #undef __libelf_i32_t + + /* Define to a 32-bit unsigned integer type if one exists */ + #undef __libelf_u32_t + + /* Define to a 16-bit signed integer type if one exists */ + #undef __libelf_i16_t + + /* Define to a 16-bit unsigned integer type if one exists */ + #undef __libelf_u16_t + + /* + * Ok, now get the correct instance of elf.h... + */ + #ifdef __LIBELF_HEADER_ELF_H + # include __LIBELF_HEADER_ELF_H + #else /* __LIBELF_HEADER_ELF_H */ + # if __LIBELF_INTERNAL__ + # include + # else /* __LIBELF_INTERNAL__ */ + # include + # endif /* __LIBELF_INTERNAL__ */ + #endif /* __LIBELF_HEADER_ELF_H */ + + /* + * On some systems, is severely broken. Try to fix it. + */ + #ifdef __LIBELF_HEADER_ELF_H + + # ifndef ELF32_FSZ_ADDR + # define ELF32_FSZ_ADDR 4 + # define ELF32_FSZ_HALF 2 + # define ELF32_FSZ_OFF 4 + # define ELF32_FSZ_SWORD 4 + # define ELF32_FSZ_WORD 4 + # endif /* ELF32_FSZ_ADDR */ + + # ifndef STN_UNDEF + # define STN_UNDEF 0 + # endif /* STN_UNDEF */ + + # if __LIBELF64 + + # ifndef ELF64_FSZ_ADDR + # define ELF64_FSZ_ADDR 8 + # define ELF64_FSZ_HALF 2 + # define ELF64_FSZ_OFF 8 + # define ELF64_FSZ_SWORD 4 + # define ELF64_FSZ_WORD 4 + # define ELF64_FSZ_SXWORD 8 + # define ELF64_FSZ_XWORD 8 + # endif /* ELF64_FSZ_ADDR */ + + # ifndef ELF64_ST_BIND + # define ELF64_ST_BIND(i) ((i)>>4) + # define ELF64_ST_TYPE(i) ((i)&0xf) + # define ELF64_ST_INFO(b,t) (((b)<<4)+((t)&0xf)) + # endif /* ELF64_ST_BIND */ + + # ifndef ELF64_R_SYM + # define ELF64_R_SYM(i) ((Elf64_Xword)(i)>>32) + # define ELF64_R_TYPE(i) ((i)&0xffffffffL) + # define ELF64_R_INFO(s,t) (((Elf64_Xword)(s)<<32)+((t)&0xffffffffL)) + # endif /* ELF64_R_SYM */ + + # if __LIBELF64_LINUX + typedef __libelf_u64_t Elf64_Addr; + typedef __libelf_u16_t Elf64_Half; + typedef __libelf_u64_t Elf64_Off; + typedef __libelf_i32_t Elf64_Sword; + typedef __libelf_u32_t Elf64_Word; + typedef __libelf_i64_t Elf64_Sxword; + typedef __libelf_u64_t Elf64_Xword; + # endif /* __LIBELF64_LINUX */ + + # endif /* __LIBELF64 */ + #endif /* __LIBELF_HEADER_ELF_H */ Index: llvm/lib/CodeGen/ELF/lib/update.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/update.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/update.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,977 ---- + /* + update.c - implementation of the elf_update(3) function. + Copyright (C) 1995 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: update.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if HAVE_MMAP + #include + #endif /* HAVE_MMAP */ + + static const unsigned short __encoding = ELFDATA2LSB + (ELFDATA2MSB << 8); + #define native_encoding (*(unsigned char*)&__encoding) + + #define rewrite(var,val,f) \ + do{if((var)!=(val)){(var)=(val);(f)|=ELF_F_DIRTY;}}while(0) + + #define align(var,val) \ + do{if((val)>1){(var)+=(val)-1;(var)-=(var)%(val);}}while(0) + + #define max(a,b) ((a)>(b)?(a):(b)) + + static off_t + scn_data_layout(Elf_Scn *scn, unsigned v, unsigned type, size_t *algn, unsigned *flag) { + Elf *elf = scn->s_elf; + Elf_Data *data; + int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0; + size_t scn_align = 1; + size_t len = 0; + Scn_Data *sd; + size_t fsize; + + if (!(sd = scn->s_data_1)) { + /* no data in section */ + *algn = scn_align; + return (off_t)len; + } + /* load data from file, if any */ + if (!(data = elf_getdata(scn, NULL))) { + return (off_t)-1; + } + elf_assert(data == &sd->sd_data); + for (; sd; sd = sd->sd_link) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + + if (!valid_version(sd->sd_data.d_version)) { + return (off_t)-1; + } + + fsize = sd->sd_data.d_size; + if (fsize && type != SHT_NOBITS && valid_type(sd->sd_data.d_type)) { + if (elf->e_class == ELFCLASS32) { + fsize = _elf32_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1); + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + fsize = _elf64_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1); + } + #endif /* __LIBELF64 */ + else { + elf_assert(valid_class(elf->e_class)); + seterr(ERROR_UNIMPLEMENTED); + return (off_t)-1; + } + if (fsize == (size_t)-1) { + return (off_t)-1; + } + } + + if (layout) { + align(len, sd->sd_data.d_align); + scn_align = max(scn_align, sd->sd_data.d_align); + rewrite(sd->sd_data.d_off, (off_t)len, sd->sd_data_flags); + len += fsize; + } + else { + len = max(len, sd->sd_data.d_off + fsize); + } + + *flag |= sd->sd_data_flags; + } + *algn = scn_align; + return (off_t)len; + } + + static size_t + scn_entsize(const Elf *elf, unsigned version, unsigned stype) { + Elf_Type type; + + switch ((type = _elf_scn_type(stype))) { + case ELF_T_BYTE: + return 0; + case ELF_T_VDEF: + case ELF_T_VNEED: + return 0; /* What else can I do? Thank you, Sun! */ + default: + return _fsize(elf->e_class, version, type); + } + } + + static off_t + _elf32_layout(Elf *elf, unsigned *flag) { + int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0; + Elf32_Ehdr *ehdr = (Elf32_Ehdr*)elf->e_ehdr; + size_t off = 0; + unsigned version; + unsigned encoding; + size_t align_addr; + size_t entsize; + unsigned shnum; + Elf_Scn *scn; + + *flag = elf->e_elf_flags | elf->e_phdr_flags; + + if ((version = ehdr->e_version) == EV_NONE) { + version = EV_CURRENT; + } + if (!valid_version(version)) { + seterr(ERROR_UNKNOWN_VERSION); + return -1; + } + if ((encoding = ehdr->e_ident[EI_DATA]) == ELFDATANONE) { + encoding = native_encoding; + } + if (!valid_encoding(encoding)) { + seterr(ERROR_UNKNOWN_ENCODING); + return -1; + } + entsize = _fsize(ELFCLASS32, version, ELF_T_EHDR); + elf_assert(entsize); + rewrite(ehdr->e_ehsize, entsize, elf->e_ehdr_flags); + off = entsize; + + align_addr = _fsize(ELFCLASS32, version, ELF_T_ADDR); + elf_assert(align_addr); + + if (elf->e_phnum) { + entsize = _fsize(ELFCLASS32, version, ELF_T_PHDR); + elf_assert(entsize); + if (layout) { + align(off, align_addr); + rewrite(ehdr->e_phoff, off, elf->e_ehdr_flags); + off += elf->e_phnum * entsize; + } + else { + off = max(off, ehdr->e_phoff + elf->e_phnum * entsize); + } + } + else { + entsize = 0; + if (layout) { + rewrite(ehdr->e_phoff, 0, elf->e_ehdr_flags); + } + } + rewrite(ehdr->e_phnum, elf->e_phnum, elf->e_ehdr_flags); + rewrite(ehdr->e_phentsize, entsize, elf->e_ehdr_flags); + + for (scn = elf->e_scn_1, shnum = 0; scn; scn = scn->s_link, ++shnum) { + Elf32_Shdr *shdr = &scn->s_shdr32; + size_t scn_align = 1; + off_t len; + + elf_assert(scn->s_index == shnum); + + *flag |= scn->s_scn_flags; + + if (scn->s_index == SHN_UNDEF) { + rewrite(shdr->sh_entsize, 0, scn->s_shdr_flags); + if (layout) { + rewrite(shdr->sh_offset, 0, scn->s_shdr_flags); + rewrite(shdr->sh_size, 0, scn->s_shdr_flags); + rewrite(shdr->sh_addralign, 0, scn->s_shdr_flags); + } + *flag |= scn->s_shdr_flags; + continue; + } + if (shdr->sh_type == SHT_NULL) { + *flag |= scn->s_shdr_flags; + continue; + } + + len = scn_data_layout(scn, version, shdr->sh_type, &scn_align, flag); + if (len == -1) { + return -1; + } + + /* + * Never override the program's choice. + */ + if (shdr->sh_entsize == 0) { + entsize = scn_entsize(elf, version, shdr->sh_type); + if (entsize > 1) { + rewrite(shdr->sh_entsize, entsize, scn->s_shdr_flags); + } + } + + if (layout) { + align(off, scn_align); + rewrite(shdr->sh_offset, off, scn->s_shdr_flags); + rewrite(shdr->sh_size, (size_t)len, scn->s_shdr_flags); + rewrite(shdr->sh_addralign, scn_align, scn->s_shdr_flags); + + if (shdr->sh_type != SHT_NOBITS) { + off += (size_t)len; + } + } + else if ((size_t)len > shdr->sh_size) { + seterr(ERROR_SCN2SMALL); + return -1; + } + else { + Elf_Scn *scn2; + size_t end1, end2; + + end1 = shdr->sh_offset; + if (shdr->sh_type != SHT_NOBITS) { + end1 += shdr->sh_size; + } + if (shdr->sh_offset < off) { + /* + * check for overlapping sections + */ + for (scn2 = elf->e_scn_1; scn2; scn2 = scn2->s_link) { + if (scn2 == scn) { + break; + } + end2 = scn2->s_shdr32.sh_offset; + if (scn2->s_shdr32.sh_type != SHT_NOBITS) { + end2 += scn2->s_shdr32.sh_size; + } + if (end1 > scn2->s_shdr32.sh_offset + && end2 > shdr->sh_offset) { + seterr(ERROR_SCN_OVERLAP); + return -1; + } + } + } + if (off < end1) { + off = end1; + } + } + *flag |= scn->s_shdr_flags; + } + + if (shnum) { + entsize = _fsize(ELFCLASS32, version, ELF_T_SHDR); + elf_assert(entsize); + if (layout) { + align(off, align_addr); + rewrite(ehdr->e_shoff, off, elf->e_ehdr_flags); + off += shnum * entsize; + } + else { + off = max(off, ehdr->e_shoff + shnum * entsize); + } + } + else { + entsize = 0; + if (layout) { + rewrite(ehdr->e_shoff, 0, elf->e_ehdr_flags); + } + } + if (shnum >= SHN_LORESERVE) { + Elf_Scn *scn = elf->e_scn_1; + Elf32_Shdr *shdr = &scn->s_shdr32; + + elf_assert(scn->s_index == 0); + rewrite(shdr->sh_size, shnum, scn->s_shdr_flags); + *flag |= scn->s_shdr_flags; + shnum = 0; + } + rewrite(ehdr->e_shnum, shnum, elf->e_ehdr_flags); + rewrite(ehdr->e_shentsize, entsize, elf->e_ehdr_flags); + + rewrite(ehdr->e_ident[EI_MAG0], ELFMAG0, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG1], ELFMAG1, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG2], ELFMAG2, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG3], ELFMAG3, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_CLASS], ELFCLASS32, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_DATA], encoding, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_VERSION], version, elf->e_ehdr_flags); + rewrite(ehdr->e_version, version, elf->e_ehdr_flags); + + *flag |= elf->e_ehdr_flags; + + return off; + } + + #if __LIBELF64 + + static off_t + _elf64_layout(Elf *elf, unsigned *flag) { + int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0; + Elf64_Ehdr *ehdr = (Elf64_Ehdr*)elf->e_ehdr; + size_t off = 0; + unsigned version; + unsigned encoding; + size_t align_addr; + size_t entsize; + unsigned shnum; + Elf_Scn *scn; + + *flag = elf->e_elf_flags | elf->e_phdr_flags; + + if ((version = ehdr->e_version) == EV_NONE) { + version = EV_CURRENT; + } + if (!valid_version(version)) { + seterr(ERROR_UNKNOWN_VERSION); + return -1; + } + if ((encoding = ehdr->e_ident[EI_DATA]) == ELFDATANONE) { + encoding = native_encoding; + } + if (!valid_encoding(encoding)) { + seterr(ERROR_UNKNOWN_ENCODING); + return -1; + } + entsize = _fsize(ELFCLASS64, version, ELF_T_EHDR); + elf_assert(entsize); + rewrite(ehdr->e_ehsize, entsize, elf->e_ehdr_flags); + off = entsize; + + align_addr = _fsize(ELFCLASS64, version, ELF_T_ADDR); + elf_assert(align_addr); + + if (elf->e_phnum) { + entsize = _fsize(ELFCLASS64, version, ELF_T_PHDR); + elf_assert(entsize); + if (layout) { + align(off, align_addr); + rewrite(ehdr->e_phoff, off, elf->e_ehdr_flags); + off += elf->e_phnum * entsize; + } + else { + off = max(off, ehdr->e_phoff + elf->e_phnum * entsize); + } + } + else { + entsize = 0; + if (layout) { + rewrite(ehdr->e_phoff, 0, elf->e_ehdr_flags); + } + } + rewrite(ehdr->e_phnum, elf->e_phnum, elf->e_ehdr_flags); + rewrite(ehdr->e_phentsize, entsize, elf->e_ehdr_flags); + + for (scn = elf->e_scn_1, shnum = 0; scn; scn = scn->s_link, ++shnum) { + Elf64_Shdr *shdr = &scn->s_shdr64; + size_t scn_align = 1; + off_t len; + + elf_assert(scn->s_index == shnum); + + *flag |= scn->s_scn_flags; + + if (scn->s_index == SHN_UNDEF) { + rewrite(shdr->sh_entsize, 0, scn->s_shdr_flags); + if (layout) { + rewrite(shdr->sh_offset, 0, scn->s_shdr_flags); + rewrite(shdr->sh_size, 0, scn->s_shdr_flags); + rewrite(shdr->sh_addralign, 0, scn->s_shdr_flags); + } + *flag |= scn->s_shdr_flags; + continue; + } + if (shdr->sh_type == SHT_NULL) { + *flag |= scn->s_shdr_flags; + continue; + } + + len = scn_data_layout(scn, version, shdr->sh_type, &scn_align, flag); + if (len == -1) { + return -1; + } + + /* + * Never override the program's choice. + */ + if (shdr->sh_entsize == 0) { + entsize = scn_entsize(elf, version, shdr->sh_type); + if (entsize > 1) { + rewrite(shdr->sh_entsize, entsize, scn->s_shdr_flags); + } + } + + if (layout) { + align(off, scn_align); + rewrite(shdr->sh_offset, off, scn->s_shdr_flags); + rewrite(shdr->sh_size, (size_t)len, scn->s_shdr_flags); + rewrite(shdr->sh_addralign, scn_align, scn->s_shdr_flags); + + if (shdr->sh_type != SHT_NOBITS) { + off += (size_t)len; + } + } + else if ((size_t)len > shdr->sh_size) { + seterr(ERROR_SCN2SMALL); + return -1; + } + else { + Elf_Scn *scn2; + size_t end1, end2; + + end1 = shdr->sh_offset; + if (shdr->sh_type != SHT_NOBITS) { + end1 += shdr->sh_size; + } + if (shdr->sh_offset < off) { + /* + * check for overlapping sections + */ + for (scn2 = elf->e_scn_1; scn2; scn2 = scn2->s_link) { + if (scn2 == scn) { + break; + } + end2 = scn2->s_shdr64.sh_offset; + if (scn2->s_shdr64.sh_type != SHT_NOBITS) { + end2 += scn2->s_shdr64.sh_size; + } + if (end1 > scn2->s_shdr64.sh_offset + && end2 > shdr->sh_offset) { + seterr(ERROR_SCN_OVERLAP); + return -1; + } + } + } + if (off < end1) { + off = end1; + } + } + *flag |= scn->s_shdr_flags; + } + + if (shnum) { + entsize = _fsize(ELFCLASS64, version, ELF_T_SHDR); + elf_assert(entsize); + if (layout) { + align(off, align_addr); + rewrite(ehdr->e_shoff, off, elf->e_ehdr_flags); + off += shnum * entsize; + } + else { + off = max(off, ehdr->e_shoff + shnum * entsize); + } + } + else { + entsize = 0; + if (layout) { + rewrite(ehdr->e_shoff, 0, elf->e_ehdr_flags); + } + } + if (shnum >= SHN_LORESERVE) { + Elf_Scn *scn = elf->e_scn_1; + Elf64_Shdr *shdr = &scn->s_shdr64; + + elf_assert(scn->s_index == 0); + rewrite(shdr->sh_size, shnum, scn->s_shdr_flags); + *flag |= scn->s_shdr_flags; + shnum = 0; + } + rewrite(ehdr->e_shnum, shnum, elf->e_ehdr_flags); + rewrite(ehdr->e_shentsize, entsize, elf->e_ehdr_flags); + + rewrite(ehdr->e_ident[EI_MAG0], ELFMAG0, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG1], ELFMAG1, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG2], ELFMAG2, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_MAG3], ELFMAG3, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_CLASS], ELFCLASS64, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_DATA], encoding, elf->e_ehdr_flags); + rewrite(ehdr->e_ident[EI_VERSION], version, elf->e_ehdr_flags); + rewrite(ehdr->e_version, version, elf->e_ehdr_flags); + + *flag |= elf->e_ehdr_flags; + + return off; + } + + #endif /* __LIBELF64 */ + + #define ptrinside(p,a,l) ((p)>=(a)&&(p)<(a)+(l)) + #define newptr(p,o,n) ((p)=((p)-(o))+(n)) + + static int + _elf_update_pointers(Elf *elf, char *outbuf, size_t len) { + Elf_Scn *scn; + Scn_Data *sd; + char *data, *rawdata; + + elf_assert(elf); + elf_assert(elf->e_data); + elf_assert(!elf->e_parent); + elf_assert(!elf->e_unmap_data); + elf_assert(elf->e_kind == ELF_K_ELF); + elf_assert(len >= EI_NIDENT); + + /* resize memory images */ + if (len <= elf->e_dsize) { + /* don't shorten the memory image */ + data = elf->e_data; + } + else if ((data = (char*)realloc(elf->e_data, len))) { + elf->e_dsize = len; + } + else { + seterr(ERROR_IO_2BIG); + return -1; + } + if (elf->e_rawdata == elf->e_data) { + /* update frozen raw image */ + memcpy(data, outbuf, len); + elf->e_data = elf->e_rawdata = data; + /* cooked data is stored outside the raw image */ + return 0; + } + if (elf->e_rawdata) { + /* update raw image */ + if (!(rawdata = (char*)realloc(elf->e_rawdata, len))) { + seterr(ERROR_IO_2BIG); + return -1; + } + memcpy(rawdata, outbuf, len); + elf->e_rawdata = rawdata; + } + if (data == elf->e_data) { + /* nothing more to do */ + return 0; + } + /* adjust internal pointers */ + if (elf->e_ehdr && !elf->e_free_ehdr) { + elf_assert(ptrinside(elf->e_ehdr, elf->e_data, elf->e_dsize)); + newptr(elf->e_ehdr, elf->e_data, data); + } + if (elf->e_phdr && !elf->e_free_phdr) { + elf_assert(ptrinside(elf->e_phdr, elf->e_data, elf->e_dsize)); + newptr(elf->e_phdr, elf->e_data, data); + } + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + if ((sd = scn->s_data_1)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (sd->sd_memdata && !sd->sd_free_data) { + elf_assert(ptrinside(sd->sd_memdata, elf->e_data, elf->e_dsize)); + if (sd->sd_data.d_buf == sd->sd_memdata) { + newptr(sd->sd_memdata, elf->e_data, data); + sd->sd_data.d_buf = sd->sd_memdata; + } + else { + newptr(sd->sd_memdata, elf->e_data, data); + } + } + } + if ((sd = scn->s_rawdata)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (sd->sd_memdata && sd->sd_free_data) { + size_t off, len; + + if (elf->e_class == ELFCLASS32) { + off = scn->s_shdr32.sh_offset; + len = scn->s_shdr32.sh_size; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + off = scn->s_shdr64.sh_offset; + len = scn->s_shdr64.sh_size; + } + #endif /* __LIBELF64 */ + else { + seterr(ERROR_UNIMPLEMENTED); + return -1; + } + if (!(rawdata = (char*)realloc(sd->sd_memdata, len))) { + seterr(ERROR_IO_2BIG); + return -1; + } + memcpy(rawdata, outbuf + off, len); + if (sd->sd_data.d_buf == sd->sd_memdata) { + sd->sd_data.d_buf = rawdata; + } + sd->sd_memdata = rawdata; + } + } + } + elf->e_data = data; + return 0; + } + + #undef ptrinside + #undef newptr + + static off_t + _elf32_write(Elf *elf, char *outbuf, size_t len) { + Elf32_Ehdr *ehdr; + Elf32_Shdr *shdr; + Elf_Scn *scn; + Scn_Data *sd; + Elf_Data src; + Elf_Data dst; + unsigned encode; + + elf_assert(len); + elf_assert(elf->e_ehdr); + ehdr = (Elf32_Ehdr*)elf->e_ehdr; + encode = ehdr->e_ident[EI_DATA]; + + src.d_buf = ehdr; + src.d_type = ELF_T_EHDR; + src.d_size = _msize(ELFCLASS32, _elf_version, ELF_T_EHDR); + src.d_version = _elf_version; + dst.d_buf = outbuf; + dst.d_size = ehdr->e_ehsize; + dst.d_version = ehdr->e_version; + if (!elf32_xlatetof(&dst, &src, encode)) { + return -1; + } + + if (ehdr->e_phnum) { + src.d_buf = elf->e_phdr; + src.d_type = ELF_T_PHDR; + src.d_size = ehdr->e_phnum * _msize(ELFCLASS32, _elf_version, ELF_T_PHDR); + src.d_version = _elf_version; + dst.d_buf = outbuf + ehdr->e_phoff; + dst.d_size = ehdr->e_phnum * ehdr->e_phentsize; + dst.d_version = ehdr->e_version; + if (!elf32_xlatetof(&dst, &src, encode)) { + return -1; + } + } + + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + + src.d_buf = &scn->s_uhdr; + src.d_type = ELF_T_SHDR; + src.d_size = _msize(ELFCLASS32, EV_CURRENT, ELF_T_SHDR); + src.d_version = EV_CURRENT; + dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize; + dst.d_size = ehdr->e_shentsize; + dst.d_version = ehdr->e_version; + if (!elf32_xlatetof(&dst, &src, encode)) { + return -1; + } + + if (scn->s_index == SHN_UNDEF) { + continue; + } + shdr = &scn->s_shdr32; + if (shdr->sh_type == SHT_NULL || shdr->sh_type == SHT_NOBITS) { + continue; + } + /* XXX: this is probably no longer necessary */ + if (scn->s_data_1 && !elf_getdata(scn, NULL)) { + return -1; + } + for (sd = scn->s_data_1; sd; sd = sd->sd_link) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + src = sd->sd_data; + if (!src.d_size) { + continue; + } + if (!src.d_buf) { + seterr(ERROR_NULLBUF); + return -1; + } + dst.d_buf = outbuf + shdr->sh_offset + src.d_off; + dst.d_size = src.d_size; + dst.d_version = ehdr->e_version; + if (valid_type(src.d_type)) { + size_t tmp; + + tmp = _elf32_xltsize(&src, dst.d_version, ELFDATA2LSB, 1); + if (tmp == (size_t)-1) { + return -1; + } + dst.d_size = tmp; + } + else { + src.d_type = ELF_T_BYTE; + } + if (!elf32_xlatetof(&dst, &src, encode)) { + return -1; + } + } + } + + /* cleanup */ + if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) { + return -1; + } + /* NOTE: ehdr is no longer valid! */ + ehdr = (Elf32_Ehdr*)elf->e_ehdr; elf_assert(ehdr); + elf->e_encoding = ehdr->e_ident[EI_DATA]; + elf->e_version = ehdr->e_ident[EI_VERSION]; + elf->e_elf_flags &= ~ELF_F_DIRTY; + elf->e_ehdr_flags &= ~ELF_F_DIRTY; + elf->e_phdr_flags &= ~ELF_F_DIRTY; + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + scn->s_scn_flags &= ~ELF_F_DIRTY; + scn->s_shdr_flags &= ~ELF_F_DIRTY; + for (sd = scn->s_data_1; sd; sd = sd->sd_link) { + sd->sd_data_flags &= ~ELF_F_DIRTY; + } + if (elf->e_readable) { + shdr = &scn->s_shdr32; + scn->s_type = shdr->sh_type; + scn->s_size = shdr->sh_size; + scn->s_offset = shdr->sh_offset; + } + } + elf->e_size = len; + return len; + } + + #if __LIBELF64 + + static off_t + _elf64_write(Elf *elf, char *outbuf, size_t len) { + Elf64_Ehdr *ehdr; + Elf64_Shdr *shdr; + Elf_Scn *scn; + Scn_Data *sd; + Elf_Data src; + Elf_Data dst; + unsigned encode; + + elf_assert(len); + elf_assert(elf->e_ehdr); + ehdr = (Elf64_Ehdr*)elf->e_ehdr; + encode = ehdr->e_ident[EI_DATA]; + + src.d_buf = ehdr; + src.d_type = ELF_T_EHDR; + src.d_size = _msize(ELFCLASS64, _elf_version, ELF_T_EHDR); + src.d_version = _elf_version; + dst.d_buf = outbuf; + dst.d_size = ehdr->e_ehsize; + dst.d_version = ehdr->e_version; + if (!elf64_xlatetof(&dst, &src, encode)) { + return -1; + } + + if (ehdr->e_phnum) { + src.d_buf = elf->e_phdr; + src.d_type = ELF_T_PHDR; + src.d_size = ehdr->e_phnum * _msize(ELFCLASS64, _elf_version, ELF_T_PHDR); + src.d_version = _elf_version; + dst.d_buf = outbuf + ehdr->e_phoff; + dst.d_size = ehdr->e_phnum * ehdr->e_phentsize; + dst.d_version = ehdr->e_version; + if (!elf64_xlatetof(&dst, &src, encode)) { + return -1; + } + } + + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(scn->s_elf == elf); + + src.d_buf = &scn->s_uhdr; + src.d_type = ELF_T_SHDR; + src.d_size = _msize(ELFCLASS64, EV_CURRENT, ELF_T_SHDR); + src.d_version = EV_CURRENT; + dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize; + dst.d_size = ehdr->e_shentsize; + dst.d_version = ehdr->e_version; + if (!elf64_xlatetof(&dst, &src, encode)) { + return -1; + } + + if (scn->s_index == SHN_UNDEF) { + continue; + } + shdr = &scn->s_shdr64; + if (shdr->sh_type == SHT_NULL || shdr->sh_type == SHT_NOBITS) { + continue; + } + /* XXX: this is probably no longer necessary */ + if (scn->s_data_1 && !elf_getdata(scn, NULL)) { + return -1; + } + for (sd = scn->s_data_1; sd; sd = sd->sd_link) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + src = sd->sd_data; + if (!src.d_size) { + continue; + } + if (!src.d_buf) { + seterr(ERROR_NULLBUF); + return -1; + } + dst.d_buf = outbuf + shdr->sh_offset + src.d_off; + dst.d_size = src.d_size; + dst.d_version = ehdr->e_version; + if (valid_type(src.d_type)) { + size_t tmp; + + tmp = _elf64_xltsize(&src, dst.d_version, ELFDATA2LSB, 1); + if (tmp == (size_t)-1) { + return -1; + } + dst.d_size = tmp; + } + else { + src.d_type = ELF_T_BYTE; + } + if (!elf64_xlatetof(&dst, &src, encode)) { + return -1; + } + } + } + + /* cleanup */ + if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) { + return -1; + } + /* NOTE: ehdr is no longer valid! */ + ehdr = (Elf64_Ehdr*)elf->e_ehdr; elf_assert(ehdr); + elf->e_encoding = ehdr->e_ident[EI_DATA]; + elf->e_version = ehdr->e_ident[EI_VERSION]; + elf->e_elf_flags &= ~ELF_F_DIRTY; + elf->e_ehdr_flags &= ~ELF_F_DIRTY; + elf->e_phdr_flags &= ~ELF_F_DIRTY; + for (scn = elf->e_scn_1; scn; scn = scn->s_link) { + scn->s_scn_flags &= ~ELF_F_DIRTY; + scn->s_shdr_flags &= ~ELF_F_DIRTY; + for (sd = scn->s_data_1; sd; sd = sd->sd_link) { + sd->sd_data_flags &= ~ELF_F_DIRTY; + } + if (elf->e_readable) { + shdr = &scn->s_shdr64; + scn->s_type = shdr->sh_type; + scn->s_size = shdr->sh_size; + scn->s_offset = shdr->sh_offset; + } + } + elf->e_size = len; + return len; + } + + #endif /* __LIBELF64 */ + + static off_t + _elf_output(Elf *elf, int fd, size_t len, off_t (*_elf_write)(Elf*, char*, size_t)) { + char *buf; + off_t err; + + elf_assert(len); + #if HAVE_FTRUNCATE + ftruncate(fd, 0); + #endif /* HAVE_FTRUNCATE */ + #if HAVE_MMAP + /* + * Make sure the file is (at least) len bytes long + */ + #if HAVE_FTRUNCATE + if (ftruncate(fd, len)) { + #else /* HAVE_FTRUNCATE */ + { + #endif /* HAVE_FTRUNCATE */ + if (lseek(fd, (off_t)len - 1, SEEK_SET) != (off_t)len - 1) { + seterr(ERROR_IO_SEEK); + return -1; + } + if (write(fd, "", 1) != 1) { + seterr(ERROR_IO_WRITE); + return -1; + } + } + buf = (void*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (buf != (char*)-1) { + if ((char)_elf_fill && !(elf->e_elf_flags & ELF_F_LAYOUT)) { + memset(buf, _elf_fill, len); + } + err = _elf_write(elf, buf, len); + munmap(buf, len); + return err; + } + #endif /* HAVE_MMAP */ + if (!(buf = (char*)malloc(len))) { + seterr(ERROR_MEM_OUTBUF); + return -1; + } + memset(buf, _elf_fill, len); + err = _elf_write(elf, buf, len); + if (err != -1 && (size_t)err == len) { + if (lseek(fd, (off_t)0, SEEK_SET)) { + seterr(ERROR_IO_SEEK); + err = -1; + } + else if (write(fd, buf, len) != len) { + seterr(ERROR_IO_WRITE); + err = -1; + } + } + free(buf); + return err; + } + + off_t + elf_update(Elf *elf, Elf_Cmd cmd) { + unsigned flag; + off_t len; + + if (!elf) { + return -1; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (cmd == ELF_C_WRITE) { + if (!elf->e_writable) { + seterr(ERROR_RDONLY); + return -1; + } + if (elf->e_disabled) { + seterr(ERROR_FDDISABLED); + return -1; + } + } + else if (cmd != ELF_C_NULL) { + seterr(ERROR_INVALID_CMD); + return -1; + } + + if (!elf->e_ehdr) { + seterr(ERROR_NOEHDR); + } + else if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + } + else if (elf->e_class == ELFCLASS32) { + len = _elf32_layout(elf, &flag); + if (len != -1 && cmd == ELF_C_WRITE && (flag & ELF_F_DIRTY)) { + len = _elf_output(elf, elf->e_fd, (size_t)len, _elf32_write); + } + return len; + } + #if __LIBELF64 + else if (elf->e_class == ELFCLASS64) { + len = _elf64_layout(elf, &flag); + if (len != -1 && cmd == ELF_C_WRITE && (flag & ELF_F_DIRTY)) { + len = _elf_output(elf, elf->e_fd, (size_t)len, _elf64_write); + } + return len; + } + #endif /* __LIBELF64 */ + else if (valid_class(elf->e_class)) { + seterr(ERROR_UNIMPLEMENTED); + } + else { + seterr(ERROR_UNKNOWN_CLASS); + } + return -1; + } Index: llvm/lib/CodeGen/ELF/lib/verdef.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verdef.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verdef.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,279 ---- + /* + verdef.h - copy versioning information. + Copyright (C) 2001 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #ifndef lint + static const char verdef_h_rcsid[] = "@(#) $Id: verdef.h,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if VER_DEF_CURRENT != 1 + #error libelf currently does not support VER_DEF_CURRENT != 1 + #endif /* VER_DEF_CURRENT != 1 */ + + #if TOFILE + + static void + __store_verdaux(verdaux_ftype *dst, const verdaux_mtype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + __store_u32L(dst->vda_name, src->vda_name); + __store_u32L(dst->vda_next, src->vda_next); + } + else { + __store_u32M(dst->vda_name, src->vda_name); + __store_u32M(dst->vda_next, src->vda_next); + } + } + + static void + __store_verdef(verdef_ftype *dst, const verdef_mtype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + __store_u16L(dst->vd_version, src->vd_version); + __store_u16L(dst->vd_flags, src->vd_flags); + __store_u16L(dst->vd_ndx, src->vd_ndx); + __store_u16L(dst->vd_cnt, src->vd_cnt); + __store_u32L(dst->vd_hash, src->vd_hash); + __store_u32L(dst->vd_aux, src->vd_aux); + __store_u32L(dst->vd_next, src->vd_next); + } + else { + __store_u16M(dst->vd_version, src->vd_version); + __store_u16M(dst->vd_flags, src->vd_flags); + __store_u16M(dst->vd_ndx, src->vd_ndx); + __store_u16M(dst->vd_cnt, src->vd_cnt); + __store_u32M(dst->vd_hash, src->vd_hash); + __store_u32M(dst->vd_aux, src->vd_aux); + __store_u32M(dst->vd_next, src->vd_next); + } + } + + typedef verdaux_mtype verdaux_stype; + typedef verdaux_ftype verdaux_dtype; + typedef verdef_mtype verdef_stype; + typedef verdef_ftype verdef_dtype; + typedef align_mtype verdef_atype; + + #define copy_verdaux_srctotmp(d, s, e) (*(d) = *(s)) + #define copy_verdaux_tmptodst(d, s, e) __store_verdaux((d), (s), (e)) + #define copy_verdef_srctotmp(d, s, e) (*(d) = *(s)) + #define copy_verdef_tmptodst(d, s, e) __store_verdef((d), (s), (e)) + + #define translator_suffix _tof + + #else /* TOFILE */ + + static void + __load_verdaux(verdaux_mtype *dst, const verdaux_ftype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + dst->vda_name = __load_u32L(src->vda_name); + dst->vda_next = __load_u32L(src->vda_next); + } + else { + dst->vda_name = __load_u32M(src->vda_name); + dst->vda_next = __load_u32M(src->vda_next); + } + } + + static void + __load_verdef(verdef_mtype *dst, const verdef_ftype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + dst->vd_version = __load_u16L(src->vd_version); + dst->vd_flags = __load_u16L(src->vd_flags); + dst->vd_ndx = __load_u16L(src->vd_ndx); + dst->vd_cnt = __load_u16L(src->vd_cnt); + dst->vd_hash = __load_u32L(src->vd_hash); + dst->vd_aux = __load_u32L(src->vd_aux); + dst->vd_next = __load_u32L(src->vd_next); + } + else { + dst->vd_version = __load_u16M(src->vd_version); + dst->vd_flags = __load_u16M(src->vd_flags); + dst->vd_ndx = __load_u16M(src->vd_ndx); + dst->vd_cnt = __load_u16M(src->vd_cnt); + dst->vd_hash = __load_u32M(src->vd_hash); + dst->vd_aux = __load_u32M(src->vd_aux); + dst->vd_next = __load_u32M(src->vd_next); + } + } + + typedef verdaux_ftype verdaux_stype; + typedef verdaux_mtype verdaux_dtype; + typedef verdef_ftype verdef_stype; + typedef verdef_mtype verdef_dtype; + typedef align_ftype verdef_atype; + + #define copy_verdaux_srctotmp(d, s, e) __load_verdaux((d), (s), (e)) + #define copy_verdaux_tmptodst(d, s, e) (*(d) = *(s)) + #define copy_verdef_srctotmp(d, s, e) __load_verdef((d), (s), (e)) + #define copy_verdef_tmptodst(d, s, e) (*(d) = *(s)) + + #define translator_suffix _tom + + #endif /* TOFILE */ + + #define cat3(a,b,c) a##b##c + #define xlt3(p,e,s) cat3(p,e,s) + #define xltprefix(x) xlt3(x,_,class_suffix) + #define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix) + + static size_t + xlt_verdef(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) { + size_t doff; + size_t soff; + + if (n < sizeof(verdef_stype)) { + return 0; + } + /* size translation shortcut */ + if (dst == NULL + && sizeof(verdef_stype) == sizeof(verdef_dtype) + && sizeof(verdaux_stype) == sizeof(verdaux_dtype)) { + return n; + } + if (src == NULL) { + seterr(ERROR_NULLBUF); + return (size_t)-1; + } + soff = doff = 0; + for (;;) { + const verdef_stype *svd; + verdef_dtype *dvd; + verdef_mtype vd; + size_t acount; + size_t aoff; + size_t save = doff; + + /* + * allocate space in dst buffer + */ + dvd = (verdef_dtype*)(dst + doff); + doff += sizeof(verdef_dtype); + /* + * load and check src + */ + svd = (verdef_stype*)(src + soff); + copy_verdef_srctotmp(&vd, svd, enc); + if (vd.vd_version < 1 + || vd.vd_version > VER_DEF_CURRENT) { + seterr(ERROR_VERDEF_VERSION); + return (size_t)-1; + } + if (vd.vd_cnt < 1 + || vd.vd_aux == 0 + || vd.vd_aux % sizeof(verdef_atype) + || vd.vd_aux < sizeof(verdef_stype)) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + /* + * get Verdaux offset and advance to next Verdef + */ + aoff = soff + vd.vd_aux; + if (vd.vd_next != 0) { + if (vd.vd_next % sizeof(verdef_atype) + || vd.vd_next < sizeof(verdef_stype)) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + soff += vd.vd_next; + if (soff + sizeof(verdef_stype) > n) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + } + /* + * read Verdaux array + */ + for (acount = 1; ; acount++) { + const verdaux_stype *svda; + verdaux_dtype *dvda; + verdaux_mtype vda; + + /* + * check for src buffer overflow + */ + if (aoff + sizeof(verdaux_stype) > n) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + /* + * allocate space in dst buffer + */ + dvda = (verdaux_dtype*)(dst + doff); + doff += sizeof(verdaux_dtype); + /* + * load and check src + */ + svda = (verdaux_stype*)(src + aoff); + copy_verdaux_srctotmp(&vda, svda, enc); + if (vda.vda_next != 0) { + if (vda.vda_next % sizeof(verdef_atype) + || vda.vda_next < sizeof(verdaux_stype)) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + aoff += vda.vda_next; + vda.vda_next = sizeof(verdaux_dtype); + } + /* + * copy Verdaux to dst buffer + */ + if (dst) { + copy_verdaux_tmptodst(dvda, &vda, enc); + } + /* + * end check + */ + if (vda.vda_next == 0) { + break; + } + } + /* + * parameter check + */ + if (acount != vd.vd_cnt) { + seterr(ERROR_VERDEF_FORMAT); + return (size_t)-1; + } + /* + * copy Verdef to dst buffer + */ + if (dst) { + vd.vd_aux = sizeof(verdef_dtype); + if (vd.vd_next != 0) { + vd.vd_next = doff - save; + } + copy_verdef_tmptodst(dvd, &vd, enc); + } + /* + * end check + */ + if (vd.vd_next == 0) { + return doff; + } + } + } + + size_t + translator(verdef,L11)(unsigned char *dst, const unsigned char *src, size_t n) { + return xlt_verdef(dst, src, n, ELFDATA2LSB); + } + + size_t + translator(verdef,M11)(unsigned char *dst, const unsigned char *src, size_t n) { + return xlt_verdef(dst, src, n, ELFDATA2MSB); + } Index: llvm/lib/CodeGen/ELF/lib/verdef_32_tof.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verdef_32_tof.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verdef_32_tof.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,53 ---- + /* + verdef_32_tof.c - copy 32-bit versioning information. + Copyright (C) 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #if __LIBELF_SYMBOL_VERSIONS + + #ifndef lint + static const char rcsid[] = "@(#) $Id: verdef_32_tof.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + typedef Elf32_Verdaux verdaux_mtype; + typedef Elf32_Verdef verdef_mtype; + typedef Elf32_Vernaux vernaux_mtype; + typedef Elf32_Verneed verneed_mtype; + typedef Elf32_Word align_mtype; + + typedef __ext_Elf32_Verdaux verdaux_ftype; + typedef __ext_Elf32_Verdef verdef_ftype; + typedef __ext_Elf32_Vernaux vernaux_ftype; + typedef __ext_Elf32_Verneed verneed_ftype; + typedef __ext_Elf32_Word align_ftype; + + #define class_suffix 32 + + #undef TOFILE + #define TOFILE 1 + + /* + * Include shared code + */ + #include "verdef.h" + #include "verneed.h" + + #endif /* __LIBELF_SYMBOL_VERSIONS */ Index: llvm/lib/CodeGen/ELF/lib/verdef_32_tom.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verdef_32_tom.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verdef_32_tom.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,53 ---- + /* + verdef_32_tom.c - copy 32-bit versioning information. + Copyright (C) 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #if __LIBELF_SYMBOL_VERSIONS + + #ifndef lint + static const char rcsid[] = "@(#) $Id: verdef_32_tom.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + typedef Elf32_Verdaux verdaux_mtype; + typedef Elf32_Verdef verdef_mtype; + typedef Elf32_Vernaux vernaux_mtype; + typedef Elf32_Verneed verneed_mtype; + typedef Elf32_Word align_mtype; + + typedef __ext_Elf32_Verdaux verdaux_ftype; + typedef __ext_Elf32_Verdef verdef_ftype; + typedef __ext_Elf32_Vernaux vernaux_ftype; + typedef __ext_Elf32_Verneed verneed_ftype; + typedef __ext_Elf32_Word align_ftype; + + #define class_suffix 32 + + #undef TOFILE + #define TOFILE 0 + + /* + * Include shared code + */ + #include "verdef.h" + #include "verneed.h" + + #endif /* __LIBELF_SYMBOL_VERSIONS */ Index: llvm/lib/CodeGen/ELF/lib/verdef_64_tof.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verdef_64_tof.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verdef_64_tof.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,53 ---- + /* + verdef_64_tof.c - copy 64-bit versioning information. + Copyright (C) 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS + + #ifndef lint + static const char rcsid[] = "@(#) $Id: verdef_64_tof.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + typedef Elf64_Verdaux verdaux_mtype; + typedef Elf64_Verdef verdef_mtype; + typedef Elf64_Vernaux vernaux_mtype; + typedef Elf64_Verneed verneed_mtype; + typedef Elf64_Word align_mtype; + + typedef __ext_Elf64_Verdaux verdaux_ftype; + typedef __ext_Elf64_Verdef verdef_ftype; + typedef __ext_Elf64_Vernaux vernaux_ftype; + typedef __ext_Elf64_Verneed verneed_ftype; + typedef __ext_Elf64_Word align_ftype; + + #define class_suffix 64 + + #undef TOFILE + #define TOFILE 1 + + /* + * Include shared code + */ + #include "verdef.h" + #include "verneed.h" + + #endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */ Index: llvm/lib/CodeGen/ELF/lib/verdef_64_tom.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verdef_64_tom.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verdef_64_tom.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,53 ---- + /* + verdef_64_tom.c - copy 64-bit versioning information. + Copyright (C) 2001 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + #include + #include + + #if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS + + #ifndef lint + static const char rcsid[] = "@(#) $Id: verdef_64_tom.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + typedef Elf64_Verdaux verdaux_mtype; + typedef Elf64_Verdef verdef_mtype; + typedef Elf64_Vernaux vernaux_mtype; + typedef Elf64_Verneed verneed_mtype; + typedef Elf64_Word align_mtype; + + typedef __ext_Elf64_Verdaux verdaux_ftype; + typedef __ext_Elf64_Verdef verdef_ftype; + typedef __ext_Elf64_Vernaux vernaux_ftype; + typedef __ext_Elf64_Verneed verneed_ftype; + typedef __ext_Elf64_Word align_ftype; + + #define class_suffix 64 + + #undef TOFILE + #define TOFILE 0 + + /* + * Include shared code + */ + #include "verdef.h" + #include "verneed.h" + + #endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */ Index: llvm/lib/CodeGen/ELF/lib/verneed.h diff -c /dev/null llvm/lib/CodeGen/ELF/lib/verneed.h:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/verneed.h Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,283 ---- + /* + verneed.h - copy versioning information. + Copyright (C) 2001 - 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #ifndef lint + static const char verneed_h_rcsid[] = "@(#) $Id: verneed.h,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + #if VER_NEED_CURRENT != 1 + #error libelf currently does not support VER_NEED_CURRENT != 1 + #endif /* VER_NEED_CURRENT != 1 */ + + #if TOFILE + + static void + __store_vernaux(vernaux_ftype *dst, const vernaux_mtype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + __store_u32L(dst->vna_hash, src->vna_hash); + __store_u16L(dst->vna_flags, src->vna_flags); + __store_u16L(dst->vna_other, src->vna_other); + __store_u32L(dst->vna_name, src->vna_name); + __store_u32L(dst->vna_next, src->vna_next); + } + else { + __store_u32M(dst->vna_hash, src->vna_hash); + __store_u16M(dst->vna_flags, src->vna_flags); + __store_u16M(dst->vna_other, src->vna_other); + __store_u32M(dst->vna_name, src->vna_name); + __store_u32M(dst->vna_next, src->vna_next); + } + } + + static void + __store_verneed(verneed_ftype *dst, const verneed_mtype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + __store_u16L(dst->vn_version, src->vn_version); + __store_u16L(dst->vn_cnt, src->vn_cnt); + __store_u32L(dst->vn_file, src->vn_file); + __store_u32L(dst->vn_aux, src->vn_aux); + __store_u32L(dst->vn_next, src->vn_next); + } + else { + __store_u16M(dst->vn_version, src->vn_version); + __store_u16M(dst->vn_cnt, src->vn_cnt); + __store_u32M(dst->vn_file, src->vn_file); + __store_u32M(dst->vn_aux, src->vn_aux); + __store_u32M(dst->vn_next, src->vn_next); + } + } + + typedef vernaux_mtype vernaux_stype; + typedef vernaux_ftype vernaux_dtype; + typedef verneed_mtype verneed_stype; + typedef verneed_ftype verneed_dtype; + typedef align_mtype verneed_atype; + + #define copy_vernaux_srctotmp(d, s, e) (*(d) = *(s)) + #define copy_vernaux_tmptodst(d, s, e) __store_vernaux((d), (s), (e)) + #define copy_verneed_srctotmp(d, s, e) (*(d) = *(s)) + #define copy_verneed_tmptodst(d, s, e) __store_verneed((d), (s), (e)) + + #define translator_suffix _tof + + #else /* TOFILE */ + + static void + __load_vernaux(vernaux_mtype *dst, const vernaux_ftype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + dst->vna_hash = __load_u32L(src->vna_hash); + dst->vna_flags = __load_u16L(src->vna_flags); + dst->vna_other = __load_u16L(src->vna_other); + dst->vna_name = __load_u32L(src->vna_name); + dst->vna_next = __load_u32L(src->vna_next); + } + else { + dst->vna_hash = __load_u32M(src->vna_hash); + dst->vna_flags = __load_u16M(src->vna_flags); + dst->vna_other = __load_u16M(src->vna_other); + dst->vna_name = __load_u32M(src->vna_name); + dst->vna_next = __load_u32M(src->vna_next); + } + } + + static void + __load_verneed(verneed_mtype *dst, const verneed_ftype *src, unsigned enc) { + if (enc == ELFDATA2LSB) { + dst->vn_version = __load_u16L(src->vn_version); + dst->vn_cnt = __load_u16L(src->vn_cnt); + dst->vn_file = __load_u32L(src->vn_file); + dst->vn_aux = __load_u32L(src->vn_aux); + dst->vn_next = __load_u32L(src->vn_next); + } + else { + dst->vn_version = __load_u16M(src->vn_version); + dst->vn_cnt = __load_u16M(src->vn_cnt); + dst->vn_file = __load_u32M(src->vn_file); + dst->vn_aux = __load_u32M(src->vn_aux); + dst->vn_next = __load_u32M(src->vn_next); + } + } + + typedef vernaux_ftype vernaux_stype; + typedef vernaux_mtype vernaux_dtype; + typedef verneed_ftype verneed_stype; + typedef verneed_mtype verneed_dtype; + typedef align_ftype verneed_atype; + + #define copy_vernaux_srctotmp(d, s, e) __load_vernaux((d), (s), (e)) + #define copy_vernaux_tmptodst(d, s, e) (*(d) = *(s)) + #define copy_verneed_srctotmp(d, s, e) __load_verneed((d), (s), (e)) + #define copy_verneed_tmptodst(d, s, e) (*(d) = *(s)) + + #define translator_suffix _tom + + #endif /* TOFILE */ + + #define cat3(a,b,c) a##b##c + #define xlt3(p,e,s) cat3(p,e,s) + #define xltprefix(x) xlt3(x,_,class_suffix) + #define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix) + + static size_t + xlt_verneed(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) { + size_t doff; + size_t soff; + + if (n < sizeof(verneed_stype)) { + return 0; + } + /* size translation shortcut */ + if (dst == NULL + && sizeof(verneed_stype) == sizeof(verneed_dtype) + && sizeof(vernaux_stype) == sizeof(vernaux_dtype)) { + return n; + } + if (src == NULL) { + seterr(ERROR_NULLBUF); + return (size_t)-1; + } + soff = doff = 0; + for (;;) { + const verneed_stype *svn; + verneed_dtype *dvn; + verneed_mtype vn; + size_t acount; + size_t aoff; + size_t save = doff; + + /* + * allocate space in dst buffer + */ + dvn = (verneed_dtype*)(dst + doff); + doff += sizeof(verneed_dtype); + /* + * load and check src + */ + svn = (verneed_stype*)(src + soff); + copy_verneed_srctotmp(&vn, svn, enc); + if (vn.vn_version < 1 + || vn.vn_version > VER_NEED_CURRENT) { + seterr(ERROR_VERNEED_VERSION); + return (size_t)-1; + } + if (vn.vn_cnt < 1 + || vn.vn_aux == 0 + || vn.vn_aux % sizeof(verneed_atype) + || vn.vn_aux < sizeof(verneed_stype)) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + /* + * get Vernaux offset and advance to next Verneed + */ + aoff = soff + vn.vn_aux; + if (vn.vn_next != 0) { + if (vn.vn_next % sizeof(verneed_atype) + || vn.vn_next < sizeof(verneed_stype)) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + soff += vn.vn_next; + if (soff + sizeof(verneed_stype) > n) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + } + /* + * read Vernaux array + */ + for (acount = 1; ; acount++) { + const vernaux_stype *svna; + vernaux_dtype *dvna; + vernaux_mtype vna; + + /* + * check for src buffer overflow + */ + if (aoff + sizeof(vernaux_stype) > n) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + /* + * allocate space in dst buffer + */ + dvna = (vernaux_dtype*)(dst + doff); + doff += sizeof(vernaux_dtype); + /* + * load and check src + */ + svna = (vernaux_stype*)(src + aoff); + copy_vernaux_srctotmp(&vna, svna, enc); + if (vna.vna_next != 0) { + if (vna.vna_next % sizeof(verneed_atype) + || vna.vna_next < sizeof(vernaux_stype)) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + aoff += vna.vna_next; + vna.vna_next = sizeof(vernaux_dtype); + } + /* + * copy Vernaux to dst buffer + */ + if (dst) { + copy_vernaux_tmptodst(dvna, &vna, enc); + } + /* + * end check + */ + if (vna.vna_next == 0) { + break; + } + } + /* + * parameter check + */ + if (acount != vn.vn_cnt) { + seterr(ERROR_VERNEED_FORMAT); + return (size_t)-1; + } + /* + * copy Verneed to dst buffer + */ + if (dst) { + vn.vn_aux = sizeof(verneed_dtype); + if (vn.vn_next != 0) { + vn.vn_next = doff - save; + } + copy_verneed_tmptodst(dvn, &vn, enc); + } + /* + * end check + */ + if (vn.vn_next == 0) { + return doff; + } + } + } + + size_t + translator(verneed,L11)(unsigned char *dst, const unsigned char *src, size_t n) { + return xlt_verneed(dst, src, n, ELFDATA2LSB); + } + + size_t + translator(verneed,M11)(unsigned char *dst, const unsigned char *src, size_t n) { + return xlt_verneed(dst, src, n, ELFDATA2MSB); + } Index: llvm/lib/CodeGen/ELF/lib/version.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/version.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/version.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,40 ---- + /* + version.c - implementation of the elf_version(3) function. + Copyright (C) 1995 - 1998 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: version.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + unsigned + elf_version(unsigned ver) { + unsigned tmp; + + if (ver == EV_NONE) { + return EV_CURRENT; + } + if (!valid_version(ver)) { + seterr(ERROR_UNKNOWN_VERSION); + return EV_NONE; + } + tmp = _elf_version == EV_NONE ? EV_CURRENT : _elf_version; + _elf_version = ver; + return tmp; + } Index: llvm/lib/CodeGen/ELF/lib/x.movscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/x.movscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/x.movscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,112 ---- + /* + x.movscn.c - implementation of the elfx_movscn(3) function. + Copyright (C) 1995 - 2001, 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: x.movscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + size_t + elfx_movscn(Elf *elf, Elf_Scn *scn, Elf_Scn *after) { + Elf_Scn *prev; + Elf_Scn *tmp; + int off; + + if (!elf || !scn || !after) { + return SHN_UNDEF; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + return SHN_UNDEF; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(after->s_magic == SCN_MAGIC); + if (scn->s_elf != elf || after->s_elf != elf) { + seterr(ERROR_ELFSCNMISMATCH); + return SHN_UNDEF; + } + elf_assert(elf->e_scn_1); + if (scn == elf->e_scn_1) { + seterr(ERROR_NULLSCN); + return SHN_UNDEF; + } + if (scn == after || scn == after->s_link) { + /* nothing to do */ + return scn->s_index; + } + + /* + * Find previous section. + */ + prev = NULL; + for (tmp = elf->e_scn_1; tmp->s_link; tmp = tmp->s_link) { + if (tmp->s_link == scn) { + prev = tmp; + break; + } + } + elf_assert(prev != NULL); + + /* + * Update section indices + */ + off = 0; + for (tmp = elf->e_scn_1; tmp; tmp = tmp->s_link) { + if (off) { + tmp->s_index += off; + } + if (tmp == after) { + off++; + } + else if (tmp == scn) { + off--; + } + } + elf_assert(off == 0); + + /* + * Move section. + */ + prev->s_link = scn->s_link; + scn->s_link = after->s_link; + after->s_link = scn; + scn->s_index = after->s_index + 1; + if (elf->e_scn_n == scn) { + elf->e_scn_n = prev; + } + else if (elf->e_scn_n == after) { + elf->e_scn_n = scn; + } + + #if ENABLE_DEBUG + /* + * Check section indices + */ + tmp = elf->e_scn_1; + elf_assert(tmp->s_index == 0); + while (tmp->s_link) { + elf_assert(tmp->s_link->s_index == tmp->s_index + 1); + tmp = tmp->s_link; + } + #endif /* ENABLE_DEBUG */ + + return scn->s_index; + } Index: llvm/lib/CodeGen/ELF/lib/x.remscn.c diff -c /dev/null llvm/lib/CodeGen/ELF/lib/x.remscn.c:1.1 *** /dev/null Wed Jun 22 01:36:10 2005 --- llvm/lib/CodeGen/ELF/lib/x.remscn.c Wed Jun 22 01:35:57 2005 *************** *** 0 **** --- 1,119 ---- + /* + x.remscn.c - implementation of the elfx_remscn(3) function. + Copyright (C) 1995 - 2001, 2003 Michael Riepe + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + #include + + #ifndef lint + static const char rcsid[] = "@(#) $Id: x.remscn.c,v 1.1 2005/06/22 06:35:57 reid Exp $"; + #endif /* lint */ + + size_t + elfx_remscn(Elf *elf, Elf_Scn *scn) { + Elf_Scn *pscn; + Scn_Data *sd; + Scn_Data *tmp; + size_t index; + + if (!elf || !scn) { + return SHN_UNDEF; + } + elf_assert(elf->e_magic == ELF_MAGIC); + if (elf->e_kind != ELF_K_ELF) { + seterr(ERROR_NOTELF); + return SHN_UNDEF; + } + elf_assert(scn->s_magic == SCN_MAGIC); + elf_assert(elf->e_ehdr); + if (scn->s_elf != elf) { + seterr(ERROR_ELFSCNMISMATCH); + return SHN_UNDEF; + } + elf_assert(elf->e_scn_1); + if (scn == elf->e_scn_1) { + seterr(ERROR_NULLSCN); + return SHN_UNDEF; + } + + /* + * Find previous section. + */ + for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) { + if (pscn->s_link == scn) { + break; + } + } + if (pscn->s_link != scn) { + seterr(ERROR_ELFSCNMISMATCH); + return SHN_UNDEF; + } + + /* + * Unlink section. + */ + if (elf->e_scn_n == scn) { + elf->e_scn_n = pscn; + } + pscn->s_link = scn->s_link; + index = scn->s_index; + + /* + * Free section descriptor and data. + */ + for (sd = scn->s_data_1; sd; sd = tmp) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + tmp = sd->sd_link; + if (sd->sd_free_data && sd->sd_memdata) { + free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if ((sd = scn->s_rawdata)) { + elf_assert(sd->sd_magic == DATA_MAGIC); + elf_assert(sd->sd_scn == scn); + if (sd->sd_free_data && sd->sd_memdata) { + free(sd->sd_memdata); + } + if (sd->sd_freeme) { + free(sd); + } + } + if (scn->s_freeme) { + elf_assert(scn->s_index > 0); + free(scn); + } + + /* + * Adjust section indices. + */ + for (scn = pscn->s_link; scn; scn = scn->s_link) { + elf_assert(scn->s_index > index); + scn->s_index--; + } + + /* + * Adjust section count in ELF header + */ + if (_elf_update_shnum(elf, elf->e_scn_n->s_index + 1)) { + return SHN_UNDEF; + } + return index; + } From alenhar2 at cs.uiuc.edu Wed Jun 22 12:19:57 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 12:19:57 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/AlphaISelPattern.cpp AlphaInstrInfo.td Message-ID: <200506221719.MAA03212@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Alpha: AlphaISelPattern.cpp updated: 1.123 -> 1.124 AlphaInstrInfo.td updated: 1.43 -> 1.44 --- Log message: Make it easier to find alpha stuff in doxygen, and fixup labeling of memory instructions in the assembly, to allow later linking of traces with LLVM Value*s. --- Diffs of the changes: (+52 -17) AlphaISelPattern.cpp | 67 ++++++++++++++++++++++++++++++++++++++------------- AlphaInstrInfo.td | 2 - 2 files changed, 52 insertions(+), 17 deletions(-) Index: llvm/lib/Target/Alpha/AlphaISelPattern.cpp diff -u llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.123 llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.124 --- llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.123 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Target/Alpha/AlphaISelPattern.cpp Wed Jun 22 12:19:45 2005 @@ -15,6 +15,7 @@ #include "AlphaRegisterInfo.h" #include "llvm/Constants.h" // FIXME: REMOVE #include "llvm/Function.h" +#include "llvm/Module.h" #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineConstantPool.h" // FIXME: REMOVE #include "llvm/CodeGen/MachineFunction.h" @@ -443,7 +444,7 @@ /// ISel - Alpha specific code to select Alpha machine instructions for /// SelectionDAG operations. //===--------------------------------------------------------------------===// -class ISel : public SelectionDAGISel { +class AlphaISel : public SelectionDAGISel { /// AlphaLowering - This object fully describes how to lower LLVM code to an /// Alpha-specific SelectionDAG. @@ -468,7 +469,7 @@ int max_depth; public: - ISel(TargetMachine &TM) : SelectionDAGISel(AlphaLowering), AlphaLowering(TM) + AlphaISel(TargetMachine &TM) : SelectionDAGISel(AlphaLowering), AlphaLowering(TM) {} /// InstructionSelectBasicBlock - This callback is invoked by @@ -519,7 +520,7 @@ }; } -void ISel::EmitFunctionEntryCode(Function &Fn, MachineFunction &MF) { +void AlphaISel::EmitFunctionEntryCode(Function &Fn, MachineFunction &MF) { // If this function has live-in values, emit the copies from pregs to vregs at // the top of the function, before anything else. MachineBasicBlock *BB = MF.begin(); @@ -542,8 +543,9 @@ //Find the offset of the arg in it's parent's function static int getValueOffset(const Value* v) { + static int uniqneg = -1; if (v == NULL) - return 0; + return uniqneg--; const Instruction* itarget = dyn_cast(v); const BasicBlock* btarget = itarget->getParent(); @@ -559,6 +561,24 @@ return i; } +//Find the offset of the function in it's module +static int getFunctionOffset(const Function* fun) +{ + const Module* M = fun->getParent(); + + //offset due to earlier BBs + int i = 0; + for(Module::const_iterator ii = M->begin(); &*ii != fun; ++ii) + ++i; + + return i; +} + +static int getUID() +{ + static int id = 0; + return ++id; +} //Factorize a number using the list of constants static bool factorize(int v[], int res[], int size, uint64_t c) @@ -680,7 +700,7 @@ /// return a DAG expression to select that will generate the same value by /// multiplying by a magic number. See: /// -SDOperand ISel::BuildSDIVSequence(SDOperand N) { +SDOperand AlphaISel::BuildSDIVSequence(SDOperand N) { int64_t d = (int64_t)cast(N.getOperand(1))->getSignExtended(); ms magics = magic(d); // Multiply the numerator (operand 0) by the magic value @@ -706,7 +726,7 @@ /// return a DAG expression to select that will generate the same value by /// multiplying by a magic number. See: /// -SDOperand ISel::BuildUDIVSequence(SDOperand N) { +SDOperand AlphaISel::BuildUDIVSequence(SDOperand N) { unsigned d = (unsigned)cast(N.getOperand(1))->getSignExtended(); mu magics = magicu(d); @@ -781,7 +801,7 @@ } } -void ISel::MoveFP2Int(unsigned src, unsigned dst, bool isDouble) +void AlphaISel::MoveFP2Int(unsigned src, unsigned dst, bool isDouble) { unsigned Opc; if (EnableAlphaFTOI) { @@ -801,7 +821,7 @@ } } -void ISel::MoveInt2FP(unsigned src, unsigned dst, bool isDouble) +void AlphaISel::MoveInt2FP(unsigned src, unsigned dst, bool isDouble) { unsigned Opc; if (EnableAlphaFTOI) { @@ -821,7 +841,7 @@ } } -bool ISel::SelectFPSetCC(SDOperand N, unsigned dst) +bool AlphaISel::SelectFPSetCC(SDOperand N, unsigned dst) { SDNode *Node = N.Val; unsigned Opc, Tmp1, Tmp2, Tmp3; @@ -880,7 +900,7 @@ } //Check to see if the load is a constant offset from a base register -void ISel::SelectAddr(SDOperand N, unsigned& Reg, long& offset) +void AlphaISel::SelectAddr(SDOperand N, unsigned& Reg, long& offset) { unsigned opcode = N.getOpcode(); if (opcode == ISD::ADD) { @@ -904,7 +924,7 @@ return; } -void ISel::SelectBranchCC(SDOperand N) +void AlphaISel::SelectBranchCC(SDOperand N) { assert(N.getOpcode() == ISD::BRCOND && "Not a BranchCC???"); MachineBasicBlock *Dest = @@ -1015,7 +1035,7 @@ abort(); //Should never be reached } -unsigned ISel::SelectExprFP(SDOperand N, unsigned Result) +unsigned AlphaISel::SelectExprFP(SDOperand N, unsigned Result) { unsigned Tmp1, Tmp2, Tmp3; unsigned Opc = 0; @@ -1168,7 +1188,8 @@ if (EnableAlphaLSMark) { int i = getValueOffset(dyn_cast(N.getOperand(2))->getValue()); - BuildMI(BB, Alpha::MEMLABEL, 2).addImm(i); + int j = getFunctionOffset(BB->getParent()->getFunction()); + BuildMI(BB, Alpha::MEMLABEL, 3).addImm(j).addImm(i).addImm(getUID()); } if (Address.getOpcode() == ISD::GlobalAddress) { @@ -1318,7 +1339,7 @@ return 0; } -unsigned ISel::SelectExpr(SDOperand N) { +unsigned AlphaISel::SelectExpr(SDOperand N) { unsigned Result; unsigned Tmp1, Tmp2 = 0, Tmp3; unsigned Opc = 0; @@ -1482,6 +1503,13 @@ assert(opcode != ISD::SEXTLOAD && "Not zext"); break; } + if (EnableAlphaLSMark) + { + int i = getValueOffset(dyn_cast(N.getOperand(2))->getValue()); + int j = getFunctionOffset(BB->getParent()->getFunction()); + BuildMI(BB, Alpha::MEMLABEL, 3).addImm(j).addImm(i).addImm(getUID()); + } + if (Address.getOpcode() == ISD::GlobalAddress) { AlphaLowering.restoreGP(BB); Opc = GetSymVersion(Opc); @@ -2231,7 +2259,7 @@ return 0; } -void ISel::Select(SDOperand N) { +void AlphaISel::Select(SDOperand N) { unsigned Tmp1, Tmp2, Opc; unsigned opcode = N.getOpcode(); @@ -2353,6 +2381,13 @@ } } + if (EnableAlphaLSMark) + { + int i = getValueOffset(dyn_cast(N.getOperand(3))->getValue()); + int j = getFunctionOffset(BB->getParent()->getFunction()); + BuildMI(BB, Alpha::MEMLABEL, 3).addImm(j).addImm(i).addImm(getUID()); + } + if (Address.getOpcode() == ISD::GlobalAddress) { AlphaLowering.restoreGP(BB); @@ -2411,6 +2446,6 @@ /// description file. /// FunctionPass *llvm::createAlphaPatternInstructionSelector(TargetMachine &TM) { - return new ISel(TM); + return new AlphaISel(TM); } Index: llvm/lib/Target/Alpha/AlphaInstrInfo.td diff -u llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.43 llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.44 --- llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.43 Mon Jun 6 14:03:55 2005 +++ llvm/lib/Target/Alpha/AlphaInstrInfo.td Wed Jun 22 12:19:45 2005 @@ -31,7 +31,7 @@ def ADJUSTSTACKDOWN : PseudoInstAlpha<(ops ), "ADJDOWN">; def ALTENT : PseudoInstAlpha<(ops s64imm:$TARGET), "$TARGET:\n">; def PCLABEL : PseudoInstAlpha<(ops s64imm:$num), "PCMARKER_$num:\n">; -def MEMLABEL : PseudoInstAlpha<(ops s64imm:$i), "LSMARKER_$i:\n">; +def MEMLABEL : PseudoInstAlpha<(ops s64imm:$i, s64imm:$j, s64imm:$k), "LSMARKER$$$i$$$j$$$k:\n">; //***************** //These are shortcuts, the assembler expands them From alenhar2 at cs.uiuc.edu Wed Jun 22 14:48:02 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 14:48:02 -0500 Subject: [llvm-commits] CVS: llvm-gcc/gcc/config/alpha/alpha.c Message-ID: <200506221948.OAA04381@zion.cs.uiuc.edu> Changes in directory llvm-gcc/gcc/config/alpha: alpha.c updated: 1.2 -> 1.3 --- Log message: revert so as to allow new style va_args to work --- Diffs of the changes: (+0 -4) alpha.c | 4 ---- 1 files changed, 4 deletions(-) Index: llvm-gcc/gcc/config/alpha/alpha.c diff -u llvm-gcc/gcc/config/alpha/alpha.c:1.2 llvm-gcc/gcc/config/alpha/alpha.c:1.3 --- llvm-gcc/gcc/config/alpha/alpha.c:1.2 Thu Feb 24 22:28:13 2005 +++ llvm-gcc/gcc/config/alpha/alpha.c Wed Jun 22 14:47:51 2005 @@ -6092,10 +6092,6 @@ { tree base, ofs, record, type_decl; - /* ABUSE the ABI in a major way here */ - if (EMIT_LLVM) - return ptr_type_node; - if (TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK) return ptr_type_node; From alenhar2 at cs.uiuc.edu Wed Jun 22 15:38:23 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 15:38:23 -0500 Subject: [llvm-commits] CVS: llvm/docs/LangRef.html Message-ID: <200506222038.PAA04677@zion.cs.uiuc.edu> Changes in directory llvm/docs: LangRef.html updated: 1.109 -> 1.110 --- Log message: SelectionDAG is very unhappy when the argument to an intrinsic is a struct --- Diffs of the changes: (+4 -5) LangRef.html | 9 ++++----- 1 files changed, 4 insertions(+), 5 deletions(-) Index: llvm/docs/LangRef.html diff -u llvm/docs/LangRef.html:1.109 llvm/docs/LangRef.html:1.110 --- llvm/docs/LangRef.html:1.109 Sat Jun 18 13:28:17 2005 +++ llvm/docs/LangRef.html Wed Jun 22 15:38:11 2005 @@ -2317,8 +2317,7 @@ ; Demonstrate usage of llvm.va_copy and llvm.va_end %aq = alloca sbyte* - %apv = load sbyte** %ap - call void %llvm.va_copy(sbyte** %aq, sbyte* %apv) + call void %llvm.va_copy(sbyte** %aq, sbyte** %ap) call void %llvm.va_end(sbyte** %aq) ; Stop processing of arguments. @@ -2390,7 +2389,7 @@ 
   declare void %llvm.va_copy(<va_list>* <destarglist>,
-                                          <va_list> <srcarglist>)
+                                          <va_list>* <srcarglist>)
Overview:
@@ -2401,7 +2400,7 @@
Arguments:

The first argument is a pointer to a va_list element to initialize. -The second argument is a va_list element to copy from.

+The second argument is a pointer to a va_list element to copy from.

Semantics:
@@ -3262,7 +3261,7 @@ Chris Lattner
The LLVM Compiler Infrastructure
- Last modified: $Date: 2005/06/18 18:28:17 $ + Last modified: $Date: 2005/06/22 20:38:11 $ From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:55 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:55 -0500 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp Message-ID: <200506222104.QAA04950@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen/SelectionDAG: SelectionDAGISel.cpp updated: 1.61 -> 1.62 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+5 -4) SelectionDAGISel.cpp | 9 +++++---- 1 files changed, 5 insertions(+), 4 deletions(-) Index: llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp diff -u llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.61 llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.62 --- llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.61 Sat Jun 18 13:34:51 2005 +++ llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp Wed Jun 22 16:04:42 2005 @@ -855,10 +855,11 @@ std::pair TargetLowering::LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, SelectionDAG &DAG) { - // We have no sane default behavior, just emit a useful error message and bail - // out. - std::cerr << "Variable arguments handling not implemented on this target!\n"; - abort(); + //Default to returning the input list + SDOperand Val = DAG.getLoad(getPointerTy(), Chain, Src, DAG.getSrcValue(NULL)); + SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), + Val, Dest, DAG.getSrcValue(NULL)); + return std::make_pair(Result, Result); } std::pair From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:56 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:56 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp Message-ID: <200506222104.QAA04956@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/SparcV9: SparcV9BurgISel.cpp updated: 1.21 -> 1.22 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+12 -5) SparcV9BurgISel.cpp | 17 ++++++++++++----- 1 files changed, 12 insertions(+), 5 deletions(-) Index: llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp diff -u llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp:1.21 llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp:1.22 --- llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp:1.21 Sun Jun 19 00:45:00 2005 +++ llvm/lib/Target/SparcV9/SparcV9BurgISel.cpp Wed Jun 22 16:04:42 2005 @@ -2881,11 +2881,18 @@ return true; // no-op on SparcV9 case Intrinsic::vacopy: - // Simple store of current va_list (arg2) to new va_list (arg1) - mvec.push_back(BuildMI(V9::STXi, 3). - addReg(callInstr.getOperand(2)). - addReg(callInstr.getOperand(1)).addSImm(0)); - return true; + { + MachineCodeForInstruction& m1 = MachineCodeForInstruction::get(&callInstr); + TmpInstruction* VReg = + new TmpInstruction(m1, callInstr.getOperand(1)->getType()); + + // Simple store of current va_list (arg2) to new va_list (arg1) + mvec.push_back(BuildMI(V9::LDXi, 3). + addReg(callInstr.getOperand(2)).addSImm(0).addRegDef(VReg)); + mvec.push_back(BuildMI(V9::STXi, 3). + addReg(VReg).addReg(callInstr.getOperand(1)).addSImm(0)); + return true; + } } } From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:56 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:56 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/CBackend/Writer.cpp Message-ID: <200506222104.QAA04958@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/CBackend: Writer.cpp updated: 1.239 -> 1.240 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+1 -1) Writer.cpp | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-) Index: llvm/lib/Target/CBackend/Writer.cpp diff -u llvm/lib/Target/CBackend/Writer.cpp:1.239 llvm/lib/Target/CBackend/Writer.cpp:1.240 --- llvm/lib/Target/CBackend/Writer.cpp:1.239 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Target/CBackend/Writer.cpp Wed Jun 22 16:04:42 2005 @@ -1495,7 +1495,7 @@ Out << "0; "; Out << "va_copy(*(va_list*)"; writeOperand(I.getOperand(1)); - Out << ", *(va_list*)&"; + Out << ", *(va_list*)"; writeOperand(I.getOperand(2)); Out << ')'; return; From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:56 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:56 -0500 Subject: [llvm-commits] CVS: llvm/lib/AsmParser/llvmAsmParser.y Message-ID: <200506222104.QAA04955@zion.cs.uiuc.edu> Changes in directory llvm/lib/AsmParser: llvmAsmParser.y updated: 1.229 -> 1.230 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+16 -11) llvmAsmParser.y | 27 ++++++++++++++++----------- 1 files changed, 16 insertions(+), 11 deletions(-) Index: llvm/lib/AsmParser/llvmAsmParser.y diff -u llvm/lib/AsmParser/llvmAsmParser.y:1.229 llvm/lib/AsmParser/llvmAsmParser.y:1.230 --- llvm/lib/AsmParser/llvmAsmParser.y:1.229 Mon Jun 20 10:41:37 2005 +++ llvm/lib/AsmParser/llvmAsmParser.y Wed Jun 22 16:04:42 2005 @@ -749,14 +749,12 @@ } if (ObsoleteVarArgs && NewVarArgs) - { - std::cerr << "This file is corrupt in that it uses both new and old style varargs\n"; - abort(); - } + ThrowException("This file is corrupt in that it uses both new and old style varargs"); if(ObsoleteVarArgs) { if(Function* F = Result->getNamedFunction("llvm.va_start")) { - assert(F->arg_size() == 0 && "Obsolete va_start takes 0 argument!"); + if (F->arg_size() != 0) + ThrowException("Obsolete va_start takes 0 argument!"); //foo = va_start() // -> @@ -782,7 +780,9 @@ } if(Function* F = Result->getNamedFunction("llvm.va_end")) { - assert(F->arg_size() == 1 && "Obsolete va_end takes 1 argument!"); + if(F->arg_size() != 1) + ThrowException("Obsolete va_end takes 1 argument!"); + //vaend foo // -> //bar = alloca 1 of typeof(foo) @@ -804,24 +804,29 @@ } if(Function* F = Result->getNamedFunction("llvm.va_copy")) { - assert(F->arg_size() == 1 && "Obsolete va_copy takes 1 argument!"); + if(F->arg_size() != 1) + ThrowException("Obsolete va_copy takes 1 argument!"); //foo = vacopy(bar) // -> //a = alloca 1 of typeof(foo) - //vacopy(a, bar) + //b = alloca 1 of typeof(foo) + //store bar -> b + //vacopy(a, b) //foo = load a const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); const Type* ArgTy = F->getFunctionType()->getReturnType(); const Type* ArgTyPtr = PointerType::get(ArgTy); Function* NF = Result->getOrInsertFunction("llvm.va_copy", - RetTy, ArgTyPtr, ArgTy, 0); + RetTy, ArgTyPtr, ArgTyPtr, 0); while (!F->use_empty()) { CallInst* CI = cast(F->use_back()); AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI); - new CallInst(NF, a, CI->getOperand(1), "", CI); - Value* foo = new LoadInst(a, "vacopy.fix.2", CI); + AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI); + new StoreInst(CI->getOperand(1), b, CI); + new CallInst(NF, a, b, "", CI); + Value* foo = new LoadInst(a, "vacopy.fix.3", CI); CI->replaceAllUsesWith(foo); CI->getParent()->getInstList().erase(CI); } From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:56 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:56 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp Message-ID: <200506222104.QAA04966@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/PowerPC: PPC64ISelPattern.cpp updated: 1.22 -> 1.23 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+0 -14) PPC64ISelPattern.cpp | 14 -------------- 1 files changed, 14 deletions(-) Index: llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp diff -u llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp:1.22 llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp:1.23 --- llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp:1.22 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Target/PowerPC/PPC64ISelPattern.cpp Wed Jun 22 16:04:42 2005 @@ -104,10 +104,6 @@ LowerVAArgNext(SDOperand Chain, SDOperand VAList, const Type *ArgTy, SelectionDAG &DAG); - virtual std::pair - LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, - SelectionDAG &DAG); - virtual std::pair LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth, SelectionDAG &DAG); @@ -390,16 +386,6 @@ return std::make_pair(Result, Chain); } -std::pair -PPC64TargetLowering::LowerVACopy(SDOperand Chain, SDOperand Src, - SDOperand Dest, SelectionDAG &DAG) -{ - SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Chain, - Src, Dest, DAG.getSrcValue(NULL)); - return std::make_pair(Result, Result); -} - - std::pair PPC64TargetLowering:: LowerFrameReturnAddress(bool isFrameAddress, SDOperand Chain, unsigned Depth, SelectionDAG &DAG) { From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:57 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:57 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/IA64/IA64ISelPattern.cpp Message-ID: <200506222104.QAA04970@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/IA64: IA64ISelPattern.cpp updated: 1.45 -> 1.46 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+0 -13) IA64ISelPattern.cpp | 13 ------------- 1 files changed, 13 deletions(-) Index: llvm/lib/Target/IA64/IA64ISelPattern.cpp diff -u llvm/lib/Target/IA64/IA64ISelPattern.cpp:1.45 llvm/lib/Target/IA64/IA64ISelPattern.cpp:1.46 --- llvm/lib/Target/IA64/IA64ISelPattern.cpp:1.45 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Target/IA64/IA64ISelPattern.cpp Wed Jun 22 16:04:42 2005 @@ -120,10 +120,6 @@ LowerVAArgNext(SDOperand Chain, SDOperand VAList, const Type *ArgTy, SelectionDAG &DAG); - virtual std::pair - LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, - SelectionDAG &DAG); - virtual std::pair LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth, SelectionDAG &DAG); @@ -413,15 +409,6 @@ return std::make_pair(Result, Chain); } -std::pair -IA64TargetLowering::LowerVACopy(SDOperand Chain, SDOperand Src, - SDOperand Dest, SelectionDAG &DAG) -{ - SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Chain, - Src, Dest, DAG.getSrcValue(NULL)); - return std::make_pair(Result, Result); -} - std::pair IA64TargetLowering:: LowerFrameReturnAddress(bool isFrameAddress, SDOperand Chain, unsigned Depth, SelectionDAG &DAG) { From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:57 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:57 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86ISelPattern.cpp Message-ID: <200506222104.QAA04972@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/X86: X86ISelPattern.cpp updated: 1.141 -> 1.142 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+0 -13) X86ISelPattern.cpp | 13 ------------- 1 files changed, 13 deletions(-) Index: llvm/lib/Target/X86/X86ISelPattern.cpp diff -u llvm/lib/Target/X86/X86ISelPattern.cpp:1.141 llvm/lib/Target/X86/X86ISelPattern.cpp:1.142 --- llvm/lib/Target/X86/X86ISelPattern.cpp:1.141 Sat Jun 18 13:34:52 2005 +++ llvm/lib/Target/X86/X86ISelPattern.cpp Wed Jun 22 16:04:42 2005 @@ -182,10 +182,6 @@ LowerVAArgNext(SDOperand Chain, SDOperand VAList, const Type *ArgTy, SelectionDAG &DAG); - virtual std::pair - LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, - SelectionDAG &DAG); - virtual std::pair LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth, SelectionDAG &DAG); @@ -475,15 +471,6 @@ return std::make_pair(Result, Chain); } -std::pair -X86TargetLowering::LowerVACopy(SDOperand Chain, SDOperand Src, - SDOperand Dest, SelectionDAG &DAG) -{ - SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Chain, - Src, Dest, DAG.getSrcValue(NULL)); - return std::make_pair(Result, Result); -} - //===----------------------------------------------------------------------===// // Fast Calling Convention implementation //===----------------------------------------------------------------------===// From alenhar2 at cs.uiuc.edu Wed Jun 22 16:04:57 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 16:04:57 -0500 Subject: [llvm-commits] CVS: llvm/lib/Bytecode/Reader/ReaderWrappers.cpp Message-ID: <200506222104.QAA04978@zion.cs.uiuc.edu> Changes in directory llvm/lib/Bytecode/Reader: ReaderWrappers.cpp updated: 1.49 -> 1.50 --- Log message: If we support structs as va_list, we must pass pointers to them to va_copy See last commit for LangRef, this implements it on all targets. --- Diffs of the changes: (+8 -4) ReaderWrappers.cpp | 12 ++++++++---- 1 files changed, 8 insertions(+), 4 deletions(-) Index: llvm/lib/Bytecode/Reader/ReaderWrappers.cpp diff -u llvm/lib/Bytecode/Reader/ReaderWrappers.cpp:1.49 llvm/lib/Bytecode/Reader/ReaderWrappers.cpp:1.50 --- llvm/lib/Bytecode/Reader/ReaderWrappers.cpp:1.49 Sun Jun 19 09:04:55 2005 +++ llvm/lib/Bytecode/Reader/ReaderWrappers.cpp Wed Jun 22 16:04:42 2005 @@ -221,20 +221,24 @@ //foo = vacopy(bar) // -> //a = alloca 1 of typeof(foo) - //vacopy(a, bar) + //b = alloca 1 of typeof(foo) + //store bar -> b + //vacopy(a, b) //foo = load a const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); const Type* ArgTy = F->getFunctionType()->getReturnType(); const Type* ArgTyPtr = PointerType::get(ArgTy); Function* NF = M->getOrInsertFunction("llvm.va_copy", - RetTy, ArgTyPtr, ArgTy, 0); + RetTy, ArgTyPtr, ArgTyPtr, 0); for(Value::use_iterator I = F->use_begin(), E = F->use_end(); I != E;) if (CallInst* CI = dyn_cast(*I++)) { AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI); - new CallInst(NF, a, CI->getOperand(1), "", CI); - Value* foo = new LoadInst(a, "vacopy.fix.2", CI); + AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI); + new StoreInst(CI->getOperand(1), b, CI); + new CallInst(NF, a, b, "", CI); + Value* foo = new LoadInst(a, "vacopy.fix.3", CI); CI->replaceAllUsesWith(foo); CI->getParent()->getInstList().erase(CI); } From alenhar2 at cs.uiuc.edu Wed Jun 22 18:04:40 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Wed, 22 Jun 2005 18:04:40 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/AlphaISelPattern.cpp Message-ID: <200506222304.SAA05897@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Alpha: AlphaISelPattern.cpp updated: 1.124 -> 1.125 --- Log message: more complete Lowering for vacopy and vaarg --- Diffs of the changes: (+29 -1) AlphaISelPattern.cpp | 30 +++++++++++++++++++++++++++++- 1 files changed, 29 insertions(+), 1 deletion(-) Index: llvm/lib/Target/Alpha/AlphaISelPattern.cpp diff -u llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.124 llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.125 --- llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.124 Wed Jun 22 12:19:45 2005 +++ llvm/lib/Target/Alpha/AlphaISelPattern.cpp Wed Jun 22 18:04:28 2005 @@ -159,6 +159,10 @@ LowerVAArgNext(SDOperand Chain, SDOperand VAList, const Type *ArgTy, SelectionDAG &DAG); + std::pair + LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, + SelectionDAG &DAG); + virtual std::pair LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, unsigned Depth, SelectionDAG &DAG); @@ -418,7 +422,17 @@ DAG.getConstant(8, MVT::i64)); SDOperand Offset = DAG.getLoad(MVT::i64, Chain, Tmp, DAG.getSrcValue(NULL)); SDOperand DataPtr = DAG.getNode(ISD::ADD, MVT::i64, Base, Offset); - SDOperand Result = DAG.getLoad(MVT::i64, Chain, DataPtr, + if (ArgTy->isFloatingPoint()) + { + //if fp && Offset < 6*8, then subtract 6*8 from DataPtr + SDOperand FPDataPtr = DAG.getNode(ISD::SUB, MVT::i64, DataPtr, + DAG.getConstant(8*6, MVT::i64)); + SDOperand CC = DAG.getSetCC(ISD::SETLT, MVT::i64, + Offset, DAG.getConstant(8*6, MVT::i64)); + DataPtr = DAG.getNode(ISD::SELECT, MVT::i64, CC, FPDataPtr, DataPtr); + } + + SDOperand Result = DAG.getLoad(getValueType(ArgTy), Chain, DataPtr, DAG.getSrcValue(NULL)); SDOperand NewOffset = DAG.getNode(ISD::ADD, MVT::i64, Offset, DAG.getConstant(8, MVT::i64)); @@ -427,6 +441,20 @@ return std::make_pair(Result, Update); } +std::pair AlphaTargetLowering:: +LowerVACopy(SDOperand Chain, SDOperand Src, SDOperand Dest, + SelectionDAG &DAG) { + //Default to returning the input list + SDOperand Val = DAG.getLoad(getPointerTy(), Chain, Src, DAG.getSrcValue(NULL)); + SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), + Val, Dest, DAG.getSrcValue(NULL)); + SDOperand NP = DAG.getNode(ISD::ADD, MVT::i64, Src, + DAG.getConstant(8, MVT::i64)); + Val = DAG.getLoad(MVT::i32, Chain, NP, DAG.getSrcValue(NULL)); + Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), + Val, Dest, DAG.getSrcValue(NULL)); + return std::make_pair(Result, Result); +} std::pair AlphaTargetLowering:: LowerFrameReturnAddress(bool isFrameAddress, SDOperand Chain, unsigned Depth, From sabre at nondot.org Wed Jun 22 22:36:11 2005 From: sabre at nondot.org (Chris Lattner) Date: Wed, 22 Jun 2005 22:36:11 -0500 (CDT) Subject: [llvm-commits] CVS: llvm/lib/Analysis/LoadValueNumbering.cpp In-Reply-To: <200506201502.KAA22985@zion.cs.uiuc.edu> References: <200506201502.KAA22985@zion.cs.uiuc.edu> Message-ID: On Mon, 20 Jun 2005, Andrew Lenharth wrote: > Log message: > > prevent GCSE from forwarding stores to loads around vaarg. This is uggly, and I am trying to fix the AliasInfo, as it should catch the problem instead. This and other related changes (e.g. LICM.cpp) are wrong: these passes don't need to know about vaarg specifically.. Please overload the "mayWriteToMemory" method in the vaarg instruction class, and revert these related patches. Thanks, -Chris > > LoadValueNumbering.cpp | 4 ++++ > 1 files changed, 4 insertions(+) > > > Index: llvm/lib/Analysis/LoadValueNumbering.cpp > diff -u llvm/lib/Analysis/LoadValueNumbering.cpp:1.31 llvm/lib/Analysis/LoadValueNumbering.cpp:1.32 > --- llvm/lib/Analysis/LoadValueNumbering.cpp:1.31 Thu Apr 21 16:04:58 2005 > +++ llvm/lib/Analysis/LoadValueNumbering.cpp Mon Jun 20 10:02:05 2005 > @@ -328,6 +328,10 @@ > LoadInvalidatedInBBBefore = true; > break; > } > + if (dyn_cast(I)) { > + LoadInvalidatedInBBBefore = true; > + break; > + } > } > > // Figure out if the load is invalidated between the load and the exit of the > > > > _______________________________________________ > llvm-commits mailing list > llvm-commits at cs.uiuc.edu > http://mail.cs.uiuc.edu/mailman/listinfo/llvm-commits > -Chris -- http://nondot.org/sabre/ http://llvm.cs.uiuc.edu/ From alenhar2 at cs.uiuc.edu Thu Jun 23 11:49:03 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Thu, 23 Jun 2005 11:49:03 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/AlphaISelPattern.cpp Message-ID: <200506231649.LAA15729@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Alpha: AlphaISelPattern.cpp updated: 1.125 -> 1.126 --- Log message: finally, Working varargs --- Diffs of the changes: (+24 -13) AlphaISelPattern.cpp | 37 ++++++++++++++++++++++++------------- 1 files changed, 24 insertions(+), 13 deletions(-) Index: llvm/lib/Target/Alpha/AlphaISelPattern.cpp diff -u llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.125 llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.126 --- llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.125 Wed Jun 22 18:04:28 2005 +++ llvm/lib/Target/Alpha/AlphaISelPattern.cpp Thu Jun 23 11:48:51 2005 @@ -403,24 +403,23 @@ std::pair AlphaTargetLowering::LowerVAStart(SDOperand Chain, SelectionDAG &DAG, SDOperand Dest) { // vastart just stores the address of the VarArgsBase and VarArgsOffset - SDOperand FR = DAG.getFrameIndex(VarArgsBase, MVT::i32); + SDOperand FR = DAG.getFrameIndex(VarArgsBase, MVT::i64); SDOperand S1 = DAG.getNode(ISD::STORE, MVT::Other, Chain, FR, Dest, DAG.getSrcValue(NULL)); SDOperand SA2 = DAG.getNode(ISD::ADD, MVT::i64, Dest, DAG.getConstant(8, MVT::i64)); - SDOperand S2 = DAG.getNode(ISD::STORE, MVT::Other, S1, + SDOperand S2 = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, S1, DAG.getConstant(VarArgsOffset, MVT::i64), SA2, - DAG.getSrcValue(NULL)); - + DAG.getSrcValue(NULL), MVT::i32); return std::make_pair(S2, S2); } std::pair AlphaTargetLowering:: LowerVAArgNext(SDOperand Chain, SDOperand VAList, const Type *ArgTy, SelectionDAG &DAG) { - //FIXME: For now, ignore FP SDOperand Base = DAG.getLoad(MVT::i64, Chain, VAList, DAG.getSrcValue(NULL)); SDOperand Tmp = DAG.getNode(ISD::ADD, MVT::i64, VAList, DAG.getConstant(8, MVT::i64)); - SDOperand Offset = DAG.getLoad(MVT::i64, Chain, Tmp, DAG.getSrcValue(NULL)); + SDOperand Offset = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, Tmp, + DAG.getSrcValue(NULL), MVT::i32); SDOperand DataPtr = DAG.getNode(ISD::ADD, MVT::i64, Base, Offset); if (ArgTy->isFloatingPoint()) { @@ -432,12 +431,23 @@ DataPtr = DAG.getNode(ISD::SELECT, MVT::i64, CC, FPDataPtr, DataPtr); } - SDOperand Result = DAG.getLoad(getValueType(ArgTy), Chain, DataPtr, - DAG.getSrcValue(NULL)); + SDOperand Result; + if (ArgTy == Type::IntTy) + Result = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, DataPtr, + DAG.getSrcValue(NULL), MVT::i32); + else if (ArgTy == Type::UIntTy) + Result = DAG.getNode(ISD::ZEXTLOAD, MVT::i64, Chain, DataPtr, + DAG.getSrcValue(NULL), MVT::i32); + else + Result = DAG.getLoad(getValueType(ArgTy), Chain, DataPtr, + DAG.getSrcValue(NULL)); + SDOperand NewOffset = DAG.getNode(ISD::ADD, MVT::i64, Offset, DAG.getConstant(8, MVT::i64)); - SDOperand Update = DAG.getNode(ISD::STORE, MVT::Other, Result, NewOffset, - Tmp, DAG.getSrcValue(NULL)); + SDOperand Update = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Result, NewOffset, + Tmp, DAG.getSrcValue(NULL), MVT::i32); + Result = DAG.getNode(ISD::TRUNCATE, getValueType(ArgTy), Result); + return std::make_pair(Result, Update); } @@ -450,9 +460,10 @@ Val, Dest, DAG.getSrcValue(NULL)); SDOperand NP = DAG.getNode(ISD::ADD, MVT::i64, Src, DAG.getConstant(8, MVT::i64)); - Val = DAG.getLoad(MVT::i32, Chain, NP, DAG.getSrcValue(NULL)); - Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), - Val, Dest, DAG.getSrcValue(NULL)); + Val = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, NP, DAG.getSrcValue(NULL), + MVT::i32); + Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Val.getValue(1), + Val, Dest, DAG.getSrcValue(NULL), MVT::i32); return std::make_pair(Result, Result); } From alenhar2 at cs.uiuc.edu Thu Jun 23 18:42:16 2005 From: alenhar2 at cs.uiuc.edu (Andrew Lenharth) Date: Thu, 23 Jun 2005 18:42:16 -0500 Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/Alpha.td AlphaISelPattern.cpp AlphaInstrInfo.td AlphaRegisterInfo.cpp Message-ID: <200506232342.SAA18186@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Alpha: Alpha.td updated: 1.3 -> 1.4 AlphaISelPattern.cpp updated: 1.126 -> 1.127 AlphaInstrInfo.td updated: 1.44 -> 1.45 AlphaRegisterInfo.cpp updated: 1.21 -> 1.22 --- Log message: remove a pseudo instruction, make ret always right, and fix vararg chains --- Diffs of the changes: (+20 -15) Alpha.td | 2 +- AlphaISelPattern.cpp | 28 ++++++++++++++++++---------- AlphaInstrInfo.td | 3 --- AlphaRegisterInfo.cpp | 2 +- 4 files changed, 20 insertions(+), 15 deletions(-) Index: llvm/lib/Target/Alpha/Alpha.td diff -u llvm/lib/Target/Alpha/Alpha.td:1.3 llvm/lib/Target/Alpha/Alpha.td:1.4 --- llvm/lib/Target/Alpha/Alpha.td:1.3 Tue Apr 5 15:51:46 2005 +++ llvm/lib/Target/Alpha/Alpha.td Thu Jun 23 18:42:05 2005 @@ -46,7 +46,7 @@ //Frame pointer // R15, //return address - R26, +// R26, //Stack Pointer // R30, F2, F3, F4, F5, F6, F7, F8, F9]; Index: llvm/lib/Target/Alpha/AlphaISelPattern.cpp diff -u llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.126 llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.127 --- llvm/lib/Target/Alpha/AlphaISelPattern.cpp:1.126 Thu Jun 23 11:48:51 2005 +++ llvm/lib/Target/Alpha/AlphaISelPattern.cpp Thu Jun 23 18:42:05 2005 @@ -76,6 +76,7 @@ int VarArgsOffset; // What is the offset to the first vaarg int VarArgsBase; // What is the base FrameIndex unsigned GP; //GOT vreg + unsigned RA; //Return Address public: AlphaTargetLowering(TargetMachine &TM) : TargetLowering(TM) { // Set up the TargetLowering object. @@ -171,6 +172,11 @@ { BuildMI(BB, Alpha::BIS, 2, Alpha::R29).addReg(GP).addReg(GP); } + void restoreRA(MachineBasicBlock* BB) + { + BuildMI(BB, Alpha::BIS, 2, Alpha::R26).addReg(RA).addReg(RA); + } + }; } @@ -262,6 +268,7 @@ int count = 0; GP = AddLiveIn(MF, Alpha::R29, getRegClassFor(MVT::i64)); + RA = AddLiveIn(MF, Alpha::R26, getRegClassFor(MVT::i64)); for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { @@ -418,7 +425,7 @@ SDOperand Base = DAG.getLoad(MVT::i64, Chain, VAList, DAG.getSrcValue(NULL)); SDOperand Tmp = DAG.getNode(ISD::ADD, MVT::i64, VAList, DAG.getConstant(8, MVT::i64)); - SDOperand Offset = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, Tmp, + SDOperand Offset = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Base.getValue(1), Tmp, DAG.getSrcValue(NULL), MVT::i32); SDOperand DataPtr = DAG.getNode(ISD::ADD, MVT::i64, Base, Offset); if (ArgTy->isFloatingPoint()) @@ -433,18 +440,18 @@ SDOperand Result; if (ArgTy == Type::IntTy) - Result = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, DataPtr, + Result = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Offset.getValue(1), DataPtr, DAG.getSrcValue(NULL), MVT::i32); else if (ArgTy == Type::UIntTy) - Result = DAG.getNode(ISD::ZEXTLOAD, MVT::i64, Chain, DataPtr, + Result = DAG.getNode(ISD::ZEXTLOAD, MVT::i64, Offset.getValue(1), DataPtr, DAG.getSrcValue(NULL), MVT::i32); else - Result = DAG.getLoad(getValueType(ArgTy), Chain, DataPtr, + Result = DAG.getLoad(getValueType(ArgTy), Offset.getValue(1), DataPtr, DAG.getSrcValue(NULL)); SDOperand NewOffset = DAG.getNode(ISD::ADD, MVT::i64, Offset, DAG.getConstant(8, MVT::i64)); - SDOperand Update = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Result, NewOffset, + SDOperand Update = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Result.getValue(1), NewOffset, Tmp, DAG.getSrcValue(NULL), MVT::i32); Result = DAG.getNode(ISD::TRUNCATE, getValueType(ArgTy), Result); @@ -460,10 +467,12 @@ Val, Dest, DAG.getSrcValue(NULL)); SDOperand NP = DAG.getNode(ISD::ADD, MVT::i64, Src, DAG.getConstant(8, MVT::i64)); - Val = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Chain, NP, DAG.getSrcValue(NULL), + Val = DAG.getNode(ISD::SEXTLOAD, MVT::i64, Result, NP, DAG.getSrcValue(NULL), MVT::i32); + SDOperand NPD = DAG.getNode(ISD::ADD, MVT::i64, Dest, + DAG.getConstant(8, MVT::i64)); Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Val.getValue(1), - Val, Dest, DAG.getSrcValue(NULL), MVT::i32); + Val, NPD, DAG.getSrcValue(NULL), MVT::i32); return std::make_pair(Result, Result); } @@ -2388,9 +2397,8 @@ Select(N.getOperand(0)); break; } - //Tmp2 = AlphaLowering.getRetAddr(); - //BuildMI(BB, Alpha::BIS, 2, Alpha::R26).addReg(Tmp2).addReg(Tmp2); - BuildMI(BB, Alpha::RETURN, 0); // Just emit a 'ret' instruction + AlphaLowering.restoreRA(BB); + BuildMI(BB, Alpha::RET, 1, Alpha::R31).addReg(Alpha::R26); // Just emit a 'ret' instruction return; case ISD::TRUNCSTORE: Index: llvm/lib/Target/Alpha/AlphaInstrInfo.td diff -u llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.44 llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.45 --- llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.44 Wed Jun 22 12:19:45 2005 +++ llvm/lib/Target/Alpha/AlphaInstrInfo.td Thu Jun 23 18:42:05 2005 @@ -53,9 +53,6 @@ Uses = [R29] in def CALL : PseudoInstAlpha< (ops s64imm:$TARGET), "jsr $TARGET">; //Jump to subroutine -let isReturn = 1, isTerminator = 1 in - def RETURN : PseudoInstAlpha<(ops ), "ret $$31,($$26),1">; //Return from subroutine - //These are evil as they get expanded into multiple instructions to take care of reallocation let Uses = [R29], Defs = [R28] in { def LOAD_ADDR : PseudoInstAlpha<(ops GPRC:$RA, s64imm:$DISP), "lda $RA,$DISP">; //Load address Index: llvm/lib/Target/Alpha/AlphaRegisterInfo.cpp diff -u llvm/lib/Target/Alpha/AlphaRegisterInfo.cpp:1.21 llvm/lib/Target/Alpha/AlphaRegisterInfo.cpp:1.22 --- llvm/lib/Target/Alpha/AlphaRegisterInfo.cpp:1.21 Fri Apr 22 12:50:14 2005 +++ llvm/lib/Target/Alpha/AlphaRegisterInfo.cpp Thu Jun 23 18:42:05 2005 @@ -272,7 +272,7 @@ const MachineFrameInfo *MFI = MF.getFrameInfo(); MachineBasicBlock::iterator MBBI = prior(MBB.end()); MachineInstr *MI; - assert((MBBI->getOpcode() == Alpha::RET || MBBI->getOpcode() == Alpha::RETURN) + assert((MBBI->getOpcode() == Alpha::RET) && "Can only insert epilog into returning blocks"); bool FP = hasFP(MF); From lattner at cs.uiuc.edu Fri Jun 24 11:00:58 2005 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri, 24 Jun 2005 11:00:58 -0500 Subject: [llvm-commits] CVS: llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp Message-ID: <200506241600.LAA23570@zion.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/IPO: DeadArgumentElimination.cpp updated: 1.24 -> 1.25 --- Log message: add a debug type --- Diffs of the changes: (+1 -0) DeadArgumentElimination.cpp | 1 + 1 files changed, 1 insertion(+) Index: llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp diff -u llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.24 llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.25 --- llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.24 Sun May 8 20:05:50 2005 +++ llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp Fri Jun 24 11:00:46 2005 @@ -17,6 +17,7 @@ // //===----------------------------------------------------------------------===// +#define DEBUG_TYPE "deadargelim" #include "llvm/Transforms/IPO.h" #include "llvm/Module.h" #include "llvm/Pass.h" From lattner at cs.uiuc.edu Fri Jun 24 12:23:09 2005 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri, 24 Jun 2005 12:23:09 -0500 Subject: [llvm-commits] CVS: llvm/docs/LangRef.html Message-ID: <200506241723.MAA24138@zion.cs.uiuc.edu> Changes in directory llvm/docs: LangRef.html updated: 1.110 -> 1.111 --- Log message: add a note about variable length array --- Diffs of the changes: (+17 -1) LangRef.html | 18 +++++++++++++++++- 1 files changed, 17 insertions(+), 1 deletion(-) Index: llvm/docs/LangRef.html diff -u llvm/docs/LangRef.html:1.110 llvm/docs/LangRef.html:1.111 --- llvm/docs/LangRef.html:1.110 Wed Jun 22 15:38:11 2005 +++ llvm/docs/LangRef.html Fri Jun 24 12:22:57 2005 @@ -717,6 +717,14 @@ + +

Note that 'variable sized arrays' can be implemented in LLVM With a zero +length array. Normally accesses past the end of an array are undefined in +LLVM (e.g. it is illegal to access the 5th element of a 3 element array). +As a special case, however, zero length arrays are recognized to be variable +length. This allows implementation of 'pascal style arrays' with the LLVM +type "{ int, [0 x float]}", for example.

+ @@ -1989,7 +1997,15 @@ ret int* %t5 } + +

Note that it is undefined to access an array out of bounds: array and +pointer indexes must always be within the defined bounds of the array type. +The one exception for this rules is zero length arrays. These arrays are +defined to be accessible as variable length arrays, which requires access +beyond the zero'th element.

+
Example:
+ 
     ; yields [12 x ubyte]*:aptr
     %aptr = getelementptr {int, [12 x ubyte]}* %sptr, long 0, uint 1
@@ -3261,7 +3277,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2005/06/22 20:38:11 $
+  Last modified: $Date: 2005/06/24 17:22:57 $
 
 
 





From lattner at cs.uiuc.edu  Fri Jun 24 13:00:51 2005
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Fri, 24 Jun 2005 13:00:51 -0500
Subject: [llvm-commits] CVS: llvm/lib/AsmParser/llvmAsmParser.y 
Message-ID: <200506241800.NAA24362@zion.cs.uiuc.edu>



Changes in directory llvm/lib/AsmParser:

llvmAsmParser.y updated: 1.230 -> 1.231
---
Log message:

Fix grammar


---
Diffs of the changes:  (+1 -1)

 llvmAsmParser.y |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/AsmParser/llvmAsmParser.y
diff -u llvm/lib/AsmParser/llvmAsmParser.y:1.230 llvm/lib/AsmParser/llvmAsmParser.y:1.231
--- llvm/lib/AsmParser/llvmAsmParser.y:1.230	Wed Jun 22 16:04:42 2005
+++ llvm/lib/AsmParser/llvmAsmParser.y	Fri Jun 24 13:00:40 2005
@@ -749,7 +749,7 @@
   }
 
   if (ObsoleteVarArgs && NewVarArgs)
-    ThrowException("This file is corrupt in that it uses both new and old style varargs");
+    ThrowException("This file is corrupt: it uses both new and old style varargs");
 
   if(ObsoleteVarArgs) {
     if(Function* F = Result->getNamedFunction("llvm.va_start")) {





From lattner at cs.uiuc.edu  Fri Jun 24 13:17:45 2005
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Fri, 24 Jun 2005 13:17:45 -0500
Subject: [llvm-commits] CVS: llvm/include/llvm/Instruction.def 
Message-ID: <200506241817.NAA24492@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Instruction.def updated: 1.15 -> 1.16
---
Log message:

improve comments


---
Diffs of the changes:  (+3 -3)

 Instruction.def |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)


Index: llvm/include/llvm/Instruction.def
diff -u llvm/include/llvm/Instruction.def:1.15 llvm/include/llvm/Instruction.def:1.16
--- llvm/include/llvm/Instruction.def:1.15	Sat Jun 18 13:31:30 2005
+++ llvm/include/llvm/Instruction.def	Fri Jun 24 13:17:33 2005
@@ -128,13 +128,13 @@
 
 HANDLE_OTHER_INST(30, Shl    , ShiftInst  )  // Shift operations
 HANDLE_OTHER_INST(31, Shr    , ShiftInst  )
- //HANDLE_OTHER_INST(32, VANext , VANextInst )  // vanext instruction
- //HANDLE_OTHER_INST(33, VAArg  , VAArgInst  )  // vaarg  instruction
+// 32 -> Empty slot used to be used for vanext in llvm 1.5 and before.
+// 33 -> Empty slot used to be used for vaarg in llvm 1.5 and before.
 HANDLE_OTHER_INST(34, Select , SelectInst )  // select instruction
 
 HANDLE_OTHER_INST(35, UserOp1, Instruction)  // May be used internally in a pass
 HANDLE_OTHER_INST(36, UserOp2, Instruction)
-HANDLE_OTHER_INST(37, VAArg  , VAArgInst  )  // vaarg  instruction
+HANDLE_OTHER_INST(37, VAArg  , VAArgInst  )  // vaarg instruction
   LAST_OTHER_INST(37)
 
 #undef  FIRST_TERM_INST





From tbrethou at cs.uiuc.edu  Fri Jun 24 21:42:31 2005
From: tbrethou at cs.uiuc.edu (Tanya Brethour)
Date: Fri, 24 Jun 2005 21:42:31 -0500
Subject: [llvm-commits] CVS: llvm-www/pubs/2005-06-17-LattnerMSThesis.html
	2005-06-17-LattnerMSThesis.pdf 2005-06-17-LattnerMSThesis.ps 
Message-ID: <200506250242.VAA02332@zion.cs.uiuc.edu>



Changes in directory llvm-www/pubs:

2005-06-17-LattnerMSThesis.html added (r1.1)
2005-06-17-LattnerMSThesis.pdf added (r1.1)
2005-06-17-LattnerMSThesis.ps added (r1.1)
---
Log message:

Adding my thesis to the publication list.


---
Diffs of the changes:  (+42529 -0)

 2005-06-17-LattnerMSThesis.html |   87 
 2005-06-17-LattnerMSThesis.pdf  |    0 
 2005-06-17-LattnerMSThesis.ps   |42442 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 42529 insertions(+)


Index: llvm-www/pubs/2005-06-17-LattnerMSThesis.html
diff -c /dev/null llvm-www/pubs/2005-06-17-LattnerMSThesis.html:1.1
*** /dev/null	Fri Jun 24 21:42:29 2005
--- llvm-www/pubs/2005-06-17-LattnerMSThesis.html	Fri Jun 24 21:42:18 2005
***************
*** 0 ****
--- 1,87 ----
+ 
+ 
+ 
+   
+   
+   An Implementation of Swing Modulo Scheduling with Extensions for Superblocks
+ 
+ 
+ 
+ 

+   An Implementation of Swing Modulo Scheduling with Extensions for Superblocks
+ 

+ 

+   Tanya M. Lattner, M.S. Thesis
+ 

+ 
+ 
+ 
Abstract:

+ 

+ 

+ This thesis details the implementation of Swing Modulo Scheduling, a
+ Software Pipelining technique, that is both effective and efficient in
+ terms of compile time and generated code. Software Pipelining aims to
+ expose Instruction Level Parallelism in loops which tend to help
+ scientific and graphical applications.

+ 
+ 
Modulo Scheduling is a category of algorithms that attempt to overlap
+ iterations of single basic block loops and schedule instructions based
+ upon a priority (derived from a set of heuristics). The approach used
+ by Swing Modulo Scheduling is designed to achieve a highly optimized
+ schedule, keeping register pressure low, and does both in a reasonable
+ amount of compile time.

+ 
+ 
One drawback of Swing Modulo Scheduling, (and all Modulo Scheduling
+ algorithms) is that they are missing opportunities for further
+ Instruction Level Parallelism by only handling single basic block
+ loops. This thesis details extensions to the Swing Modulo Scheduling
+ algorithm to handle multiple basic block loops in the form of a
+ superblock. A superblock is group of basic blocks that have a single
+ entry and multiple exits. Extending Swing Modulo Scheduling to support
+ these types of loops increases the number of loops Swing Modulo
+ Scheduling can be applied to.  In addition, it allows Modulo
+ Scheduling to be performed on hot paths (also single entry, multiple
+ exit), found with profile information to be optimized later offline or
+ at runtime.

+ 
+ 
Our implementation of Swing Modulo Scheduling and extensions to the
+ algorithm for superblock loops were evaluated and found to be both
+ effective and efficient. For the original algorithm, benchmarks were
+ transformed to have performance gains of 10-33%, while the extended
+ algorithm increased benchmark performance from 7-22%. 

+ 

+ 
+ 
Published:

+ 

+   An Implementation of Swing Modulo Scheduling with Extensions for Superblocks, Tanya M. Lattner.

+   Masters Thesis, Computer Science Dept., University of Illinois at
+   Urbana-Champaign, MONTH YEAR.
+ 

+ 
+ 
Download:

+ 
+ 
+ 

+    The "book form" is useful if you plan to print this out.  Print the file out
+    double sided, fold it in half, and staple it in the middle of the page.  It
+    dramatically reduces the number of pages of paper used.
+ 

+ 
+ 
BibTeX Entry:

+ 
+   @MastersThesis{Lattner:MSThesis05,
+     author  = {Tanya M. Lattner},
+     title   = "{An Implementation of Swing Modulo Scheduling with Extensions for Superblocks}",
+     school  = "{Computer Science Dept., University of Illinois at Urbana-Champaign}",
+     year    = {2005},
+     address = {Urbana, IL},
+     month   = {June},
+     note    = {{\em See {\tt http://llvm.cs.uiuc.edu}.}}
+   }
+ 

+ 
+ 
+ 


Index: llvm-www/pubs/2005-06-17-LattnerMSThesis.pdf


Index: llvm-www/pubs/2005-06-17-LattnerMSThesis.ps
diff -c /dev/null llvm-www/pubs/2005-06-17-LattnerMSThesis.ps:1.1
*** /dev/null	Fri Jun 24 21:42:31 2005
--- llvm-www/pubs/2005-06-17-LattnerMSThesis.ps	Fri Jun 24 21:42:19 2005
***************
*** 0 ****
--- 1,42442 ----
+ %!PS-Adobe-2.0
+ %%Creator: dvips(k) 5.90a Copyright 2002 Radical Eye Software
+ %%Title: thesis.dvi
+ %%Pages: 106
+ %%PageOrder: Ascend
+ %%BoundingBox: 0 0 612 792
+ %%DocumentFonts: CMR12 CMR10 CMBX12 CMSL10 CMR9 CMSY10 CMMI10 CMCSC10
+ %%+ CMR8 CMSY9 CMMI9 CMR6 CMBX10 CMBX8 CMMI8 CMSY8 CMBX9 CMMI6 CMTT8
+ %%+ CMSY6 CMTI10 CMTT10
+ %%EndComments
+ %DVIPSWebPage: (www.radicaleye.com)
+ %DVIPSCommandLine: dvips -o thesis.ps thesis.dvi -t letter
+ %DVIPSParameters: dpi=1200, compressed
+ %DVIPSSource:  TeX output 2005.06.24:2139
+ %%BeginProcSet: texc.pro
+ %!
+ /TeXDict 300 dict def TeXDict begin/N{def}def/B{bind def}N/S{exch}N/X{S
+ N}B/A{dup}B/TR{translate}N/isls false N/vsize 11 72 mul N/hsize 8.5 72
+ mul N/landplus90{false}def/@rigin{isls{[0 landplus90{1 -1}{-1 1}ifelse 0
+ 0 0]concat}if 72 Resolution div 72 VResolution div neg scale isls{
+ landplus90{VResolution 72 div vsize mul 0 exch}{Resolution -72 div hsize
+ mul 0}ifelse TR}if Resolution VResolution vsize -72 div 1 add mul TR[
+ matrix currentmatrix{A A round sub abs 0.00001 lt{round}if}forall round
+ exch round exch]setmatrix}N/@landscape{/isls true N}B/@manualfeed{
+ statusdict/manualfeed true put}B/@copies{/#copies X}B/FMat[1 0 0 -1 0 0]
+ N/FBB[0 0 0 0]N/nn 0 N/IEn 0 N/ctr 0 N/df-tail{/nn 8 dict N nn begin
+ /FontType 3 N/FontMatrix fntrx N/FontBBox FBB N string/base X array
+ /BitMaps X/BuildChar{CharBuilder}N/Encoding IEn N end A{/foo setfont}2
+ array copy cvx N load 0 nn put/ctr 0 N[}B/sf 0 N/df{/sf 1 N/fntrx FMat N
+ df-tail}B/dfs{div/sf X/fntrx[sf 0 0 sf neg 0 0]N df-tail}B/E{pop nn A
+ definefont setfont}B/Cw{Cd A length 5 sub get}B/Ch{Cd A length 4 sub get
+ }B/Cx{128 Cd A length 3 sub get sub}B/Cy{Cd A length 2 sub get 127 sub}
+ B/Cdx{Cd A length 1 sub get}B/Ci{Cd A type/stringtype ne{ctr get/ctr ctr
+ 1 add N}if}B/id 0 N/rw 0 N/rc 0 N/gp 0 N/cp 0 N/G 0 N/CharBuilder{save 3
+ 1 roll S A/base get 2 index get S/BitMaps get S get/Cd X pop/ctr 0 N Cdx
+ 0 Cx Cy Ch sub Cx Cw add Cy setcachedevice Cw Ch true[1 0 0 -1 -.1 Cx
+ sub Cy .1 sub]/id Ci N/rw Cw 7 add 8 idiv string N/rc 0 N/gp 0 N/cp 0 N{
+ rc 0 ne{rc 1 sub/rc X rw}{G}ifelse}imagemask restore}B/G{{id gp get/gp
+ gp 1 add N A 18 mod S 18 idiv pl S get exec}loop}B/adv{cp add/cp X}B
+ /chg{rw cp id gp 4 index getinterval putinterval A gp add/gp X adv}B/nd{
+ /cp 0 N rw exit}B/lsh{rw cp 2 copy get A 0 eq{pop 1}{A 255 eq{pop 254}{
+ A A add 255 and S 1 and or}ifelse}ifelse put 1 adv}B/rsh{rw cp 2 copy
+ get A 0 eq{pop 128}{A 255 eq{pop 127}{A 2 idiv S 128 and or}ifelse}
+ ifelse put 1 adv}B/clr{rw cp 2 index string putinterval adv}B/set{rw cp
+ fillstr 0 4 index getinterval putinterval adv}B/fillstr 18 string 0 1 17
+ {2 copy 255 put pop}for N/pl[{adv 1 chg}{adv 1 chg nd}{1 add chg}{1 add
+ chg nd}{adv lsh}{adv lsh nd}{adv rsh}{adv rsh nd}{1 add adv}{/rc X nd}{
+ 1 add set}{1 add clr}{adv 2 chg}{adv 2 chg nd}{pop nd}]A{bind pop}
+ forall N/D{/cc X A type/stringtype ne{]}if nn/base get cc ctr put nn
+ /BitMaps get S ctr S sf 1 ne{A A length 1 sub A 2 index S get sf div put
+ }if put/ctr ctr 1 add N}B/I{cc 1 add D}B/bop{userdict/bop-hook known{
+ bop-hook}if/SI save N @rigin 0 0 moveto/V matrix currentmatrix A 1 get A
+ mul exch 0 get A mul add .99 lt{/QV}{/RV}ifelse load def pop pop}N/eop{
+ SI restore userdict/eop-hook known{eop-hook}if showpage}N/@start{
+ userdict/start-hook known{start-hook}if pop/VResolution X/Resolution X
+ 1000 div/DVImag X/IEn 256 array N 2 string 0 1 255{IEn S A 360 add 36 4
+ index cvrs cvn put}for pop 65781.76 div/vsize X 65781.76 div/hsize X}N
+ /p{show}N/RMat[1 0 0 -1 0 0]N/BDot 260 string N/Rx 0 N/Ry 0 N/V{}B/RV/v{
+ /Ry X/Rx X V}B statusdict begin/product where{pop false[(Display)(NeXT)
+ (LaserWriter 16/600)]{A length product length le{A length product exch 0
+ exch getinterval eq{pop true exit}if}{pop}ifelse}forall}{false}ifelse
+ end{{gsave TR -.1 .1 TR 1 1 scale Rx Ry false RMat{BDot}imagemask
+ grestore}}{{gsave TR -.1 .1 TR Rx Ry scale 1 1 false RMat{BDot}
+ imagemask grestore}}ifelse B/QV{gsave newpath transform round exch round
+ exch itransform moveto Rx 0 rlineto 0 Ry neg rlineto Rx neg 0 rlineto
+ fill grestore}B/a{moveto}B/delta 0 N/tail{A/delta X 0 rmoveto}B/M{S p
+ delta add tail}B/b{S p tail}B/c{-4 M}B/d{-3 M}B/e{-2 M}B/f{-1 M}B/g{0 M}
+ B/h{1 M}B/i{2 M}B/j{3 M}B/k{4 M}B/w{0 rmoveto}B/l{p -4 w}B/m{p -3 w}B/n{
+ p -2 w}B/o{p -1 w}B/q{p 1 w}B/r{p 2 w}B/s{p 3 w}B/t{p 4 w}B/x{0 S
+ rmoveto}B/y{3 2 roll p a}B/bos{/SS save N}B/eos{SS restore}B end
+ 
+ %%EndProcSet
+ %%BeginProcSet: texps.pro
+ %!
+ TeXDict begin/rf{findfont dup length 1 add dict begin{1 index/FID ne 2
+ index/UniqueID ne and{def}{pop pop}ifelse}forall[1 index 0 6 -1 roll
+ exec 0 exch 5 -1 roll VResolution Resolution div mul neg 0 0]/Metrics
+ exch def dict begin Encoding{exch dup type/integertype ne{pop pop 1 sub
+ dup 0 le{pop}{[}ifelse}{FontMatrix 0 get div Metrics 0 get div def}
+ ifelse}forall Metrics/Metrics currentdict end def[2 index currentdict
+ end definefont 3 -1 roll makefont/setfont cvx]cvx def}def/ObliqueSlant{
+ dup sin S cos div neg}B/SlantFont{4 index mul add}def/ExtendFont{3 -1
+ roll mul exch}def/ReEncodeFont{CharStrings rcheck{/Encoding false def
+ dup[exch{dup CharStrings exch known not{pop/.notdef/Encoding true def}
+ if}forall Encoding{]exch pop}{cleartomark}ifelse}if/Encoding exch def}
+ def end
+ 
+ %%EndProcSet
+ %%BeginProcSet: special.pro
+ %!
+ TeXDict begin/SDict 200 dict N SDict begin/@SpecialDefaults{/hs 612 N
+ /vs 792 N/ho 0 N/vo 0 N/hsc 1 N/vsc 1 N/ang 0 N/CLIP 0 N/rwiSeen false N
+ /rhiSeen false N/letter{}N/note{}N/a4{}N/legal{}N}B/@scaleunit 100 N
+ /@hscale{@scaleunit div/hsc X}B/@vscale{@scaleunit div/vsc X}B/@hsize{
+ /hs X/CLIP 1 N}B/@vsize{/vs X/CLIP 1 N}B/@clip{/CLIP 2 N}B/@hoffset{/ho
+ X}B/@voffset{/vo X}B/@angle{/ang X}B/@rwi{10 div/rwi X/rwiSeen true N}B
+ /@rhi{10 div/rhi X/rhiSeen true N}B/@llx{/llx X}B/@lly{/lly X}B/@urx{
+ /urx X}B/@ury{/ury X}B/magscale true def end/@MacSetUp{userdict/md known
+ {userdict/md get type/dicttype eq{userdict begin md length 10 add md
+ maxlength ge{/md md dup length 20 add dict copy def}if end md begin
+ /letter{}N/note{}N/legal{}N/od{txpose 1 0 mtx defaultmatrix dtransform S
+ atan/pa X newpath clippath mark{transform{itransform moveto}}{transform{
+ itransform lineto}}{6 -2 roll transform 6 -2 roll transform 6 -2 roll
+ transform{itransform 6 2 roll itransform 6 2 roll itransform 6 2 roll
+ curveto}}{{closepath}}pathforall newpath counttomark array astore/gc xdf
+ pop ct 39 0 put 10 fz 0 fs 2 F/|______Courier fnt invertflag{PaintBlack}
+ if}N/txpose{pxs pys scale ppr aload pop por{noflips{pop S neg S TR pop 1
+ -1 scale}if xflip yflip and{pop S neg S TR 180 rotate 1 -1 scale ppr 3
+ get ppr 1 get neg sub neg ppr 2 get ppr 0 get neg sub neg TR}if xflip
+ yflip not and{pop S neg S TR pop 180 rotate ppr 3 get ppr 1 get neg sub
+ neg 0 TR}if yflip xflip not and{ppr 1 get neg ppr 0 get neg TR}if}{
+ noflips{TR pop pop 270 rotate 1 -1 scale}if xflip yflip and{TR pop pop
+ 90 rotate 1 -1 scale ppr 3 get ppr 1 get neg sub neg ppr 2 get ppr 0 get
+ neg sub neg TR}if xflip yflip not and{TR pop pop 90 rotate ppr 3 get ppr
+ 1 get neg sub neg 0 TR}if yflip xflip not and{TR pop pop 270 rotate ppr
+ 2 get ppr 0 get neg sub neg 0 S TR}if}ifelse scaleby96{ppr aload pop 4
+ -1 roll add 2 div 3 1 roll add 2 div 2 copy TR .96 dup scale neg S neg S
+ TR}if}N/cp{pop pop showpage pm restore}N end}if}if}N/normalscale{
+ Resolution 72 div VResolution 72 div neg scale magscale{DVImag dup scale
+ }if 0 setgray}N/psfts{S 65781.76 div N}N/startTexFig{/psf$SavedState
+ save N userdict maxlength dict begin/magscale true def normalscale
+ currentpoint TR/psf$ury psfts/psf$urx psfts/psf$lly psfts/psf$llx psfts
+ /psf$y psfts/psf$x psfts currentpoint/psf$cy X/psf$cx X/psf$sx psf$x
+ psf$urx psf$llx sub div N/psf$sy psf$y psf$ury psf$lly sub div N psf$sx
+ psf$sy scale psf$cx psf$sx div psf$llx sub psf$cy psf$sy div psf$ury sub
+ TR/showpage{}N/erasepage{}N/setpagedevice{pop}N/copypage{}N/p 3 def
+ @MacSetUp}N/doclip{psf$llx psf$lly psf$urx psf$ury currentpoint 6 2 roll
+ newpath 4 copy 4 2 roll moveto 6 -1 roll S lineto S lineto S lineto
+ closepath clip newpath moveto}N/endTexFig{end psf$SavedState restore}N
+ /@beginspecial{SDict begin/SpecialSave save N gsave normalscale
+ currentpoint TR @SpecialDefaults count/ocount X/dcount countdictstack N}
+ N/@setspecial{CLIP 1 eq{newpath 0 0 moveto hs 0 rlineto 0 vs rlineto hs
+ neg 0 rlineto closepath clip}if ho vo TR hsc vsc scale ang rotate
+ rwiSeen{rwi urx llx sub div rhiSeen{rhi ury lly sub div}{dup}ifelse
+ scale llx neg lly neg TR}{rhiSeen{rhi ury lly sub div dup scale llx neg
+ lly neg TR}if}ifelse CLIP 2 eq{newpath llx lly moveto urx lly lineto urx
+ ury lineto llx ury lineto closepath clip}if/showpage{}N/erasepage{}N
+ /setpagedevice{pop}N/copypage{}N newpath}N/@endspecial{count ocount sub{
+ pop}repeat countdictstack dcount sub{end}repeat grestore SpecialSave
+ restore end}N/@defspecial{SDict begin}N/@fedspecial{end}B/li{lineto}B
+ /rl{rlineto}B/rc{rcurveto}B/np{/SaveX currentpoint/SaveY X N 1
+ setlinecap newpath}N/st{stroke SaveX SaveY moveto}N/fil{fill SaveX SaveY
+ moveto}N/ellipse{/endangle X/startangle X/yrad X/xrad X/savematrix
+ matrix currentmatrix N TR xrad yrad scale 0 0 1 startangle endangle arc
+ savematrix setmatrix}N end
+ 
+ %%EndProcSet
+ %%BeginFont: CMTT10
+ %!PS-AdobeFont-1.1: CMTT10 1.00B
+ %%CreationDate: 1992 Apr 26 10:42:42
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.00B) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMTT10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch true def
+ end readonly def
+ /FontName /CMTT10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 47 /slash put
+ dup 58 /colon put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 119 /w put
+ dup 126 /asciitilde put
+ readonly def
+ /FontBBox{-4 -235 731 800}readonly def
+ /UniqueID 5000832 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F00F963068B8232429ED8B7CF6A3D879A2D19
+ 38DD5C4467F9DD8C5D1A2000B3A6BF2F25629BAEC199AE8BD4BA6ED9BBF7DABF
+ D0E153BAB1C17900D4FCE209622ACD19E7C74C2807D0397357ED07AB460D5204
+ EB3A45B7AC4D106B7303AD8348853032A745F417943F9B4FED652B835AA49727
+ A8B4117AFF1D4BCE831EB510B6851796D0BE6982B76620CB3CE0C22CACDD4593
+ F244C14EEC0E5A7C4AC42392F81C01BC4257FE12AF33F4BFEA9108FF11CF9714
+ 4DD6EC70A2C4C1E4F328A1EB25E43525FB1E16C07E28CC359DF61F426B7D41EA
+ 6A0C84DD63275395A503AAE908E1C82D389FD12A21E86999799E7F24A994472E
+ A10EAE77096709BE0D11AAD24A30D96E15A51D720AFB3B10D2E0AC8DC1A1204B
+ E8725E00D7E3A96F9978BC19377034D93D080C4391E579C34FF9FC2379CB119F
+ 1E5BBEA91AE20F343C6420BE1E2BD0636B04FCCC0BEE0DC2D56D66F06DB22438
+ 452822CBEAF03EE9EAA8398F276EC0D92A7FB978C17805DB2F4A7DFBA56FD6AF
+ 8670EB364F01DE8FCAFBAF657D68C3A03112915736CEABAA8BA5C0AC25288369
+ 5D49BD891FABEFE8699A0AE3ED85B48ACB22229E15623399C93DE7D935734ADA
+ DA7A1462C111D44AD53EA35B57E5D0B5FC0B481820E43222DB8EFCD5D30E15F9
+ BA304FA879392EE0BCC0E1A61E74B3A1FC3A3D170218D7244580C7AA0DC65D19
+ 741FA5FE6F8CBF60250ACC27454BBF0897CA4B909C83A56672958752ED4B5E79
+ E18660764F155E86F09EFA9F7685F2F5027EC85A775287B30E2069DE4E4D5712
+ E7D033481A53A2702BA7542C71062173039030CF28D8B9C63B5596A9B42B33E7
+ D922944A38713383D3648A4AF160A3B0C8F3379BA4372BE2E7EA49AABA75AEEE
+ C5DDE1D8BF68483C3D21271280ABB91D54CC819680322EAB72E1250A760BC8DC
+ FF798F2ABFC4F3539392985C4CB324B0007229586D1E0321559F67C057FD7902
+ 194490A4C133DA790FF3BF23A13C2B1B69EEB75950F9106F2BA1E3CA65C90FF5
+ 931DADF03DA48AFB8561FC2E710087251BFC42B80B297A3DB0DA138A7622A931
+ DA293B0C740987ACE9F2A8EC2DB98F85783C01623FD3612C7E4A84FD93446770
+ C3DD7431F955A5F3734F6931BD790F0A45B8D17CB74BDAA4BFF6DAB5380CBF61
+ 72F37CB67A909E2842E0AC5D9D07D01A4BABBDE2AC70FE5753460D7E1A708B7D
+ 0EFB2B5FF55F9E4571C466AF1F91E545585845B09D855C3A01F713C1BF081EB2
+ 7E2A0E598708737D475BEDAF60BC100FD0A0628C6001A203348CF6A3AFEE6DEA
+ A2EB57E35599FAD0B8A52BE1B081FC4B5664114E7A71906DB43D150337D2F47A
+ 6AE31CB21F0A689336D70C3119180B78C2066FED4D6719AC8D52F7CA1D32A22C
+ 09EE6ED97334091442AE7417DF9AA9D14397AC32017884DF605AEB42776E7AA3
+ 2EC4B0693F365B21F40371DDB117557E66E189B0113E86A8AEAAF65332E8B2F1
+ A02C0AE774464DFF46A8EA9C60586AAE6208846FFFDA056A0E84F2307B06AD9D
+ A19E3FA3B696905D49892B70588D74C76DE6CACF4C3FF495F0D3B1317D4933E1
+ E097ADD7D5177807B9B346B6550F5752C413D90672F8ADD65AEB4990BFDBC7DE
+ 0262968A80A8CF7BBB5FEB2AC20F79E7DAECA13B8648A0C71CECC4952BED6A65
+ 3C2EDB52FA4AAD8BD807245E06C7BE36235096621395758CCA84F8753325AEF8
+ 9047EDE6490B18D030E245A6F6CA40A1B1D6E2F900365D7B6792513F07BEF16E
+ DC4B0B7DD0E036C09D246869EA48DFD23492E7E980B2C4319DE439085A7372EB
+ E97ED098177D9B68B1B51C553267AC4B43187A0908EA1795C412FF962443FA28
+ 5BD5AA1A25BBE3C85B8B1E8D82BD0A396D73380B97B87926553EBAAEF3004ACE
+ 8F2F245FCA805222DF6E35C5C0EE9351A931F4E43CB16CE648F49CEB69128E0C
+ F4486812918C3E01ACE423CEC222FD456986F262B773AF0491D3B9BBE25EDBC3
+ 724CF9444CB5D5EE5CD7D6424E058F99D2FA8C2CD432BEDE04DD833C472C3FD6
+ C5DADF555E050090D6AA9922812D16B9D4931DF3EF7EAC53C5164A051DC4BB4B
+ 077352B80EA16C2D877536B82C17BC7D6FD4314E9625FE1BA3B93EDDC38D7AC8
+ 345CB65F6A8B93C7AB9706FFA292D1DF321E08F0299A636D5B3B9B48BB0B0F5B
+ C4EAC7C3CE7F9DC07C91FFF7C8F1F86AEF822A06ED1E192ACACE9685DDA1DCEE
+ 17D42937F969795702CCCF9E9396BB9E5CC0B2F7620DA72606230C4A82527832
+ E4486B329E1D953439EFF3149C5F415C01C0BD93786E6798F163E4BD7A2E0577
+ A626817588BCA80F18B63A2BBFE9758AE7E88D90DB5CD2C0A10E491C3925E8F9
+ 5A791106A47B12ED1514924B94CC83AE48D8B5B55E5BCBE03AA812E0A52ED693
+ F2A0C27D9F8C7F1220C612636DBDDC6DDFE2DDB37942A5010F80B1D1B407F6A7
+ C6C594290973DD9A46A0F4356D32EE55B2EA69059C46DEF5CC527E22BA51BA53
+ 6E6EACCEEDC9ACE3EAAB23C81ECC56FB43BDCF12A4BFB92EB7B8F5C9044A0280
+ 9E7C1EE3F0367A32656539D72673AFDBD04FAFB78C1C1F635B328365B465B566
+ 170625679107AB8D2D3CB1EAF41F0D501A88C76DA7D384403A5E495CD6550886
+ D89AF9E3F5C97A5517780DC46E7F924039685FB4B68F1CC86B8B72A1B41FF2FD
+ E2E24A064CB8AA643EC3D4FD25A45277CD4A46333E797C5011B3DCA0BFFC7357
+ 94A53CB08FADA68E782DCD52476602238653B8F14E9FE2A61CC398EA7665C8CA
+ 8026E9AD73126B4E2A73050C40E53B097FEA1FD36E674B1373345C6B16B54AF1
+ 7B4BE28A7D4D91D96765C74FB46A8EC0CAC1CC8E7D4F6F1D542BE2758D511927
+ A6BD1D7BABDADE7B9F88AAB22667A268F3B06E0525EA8276AD8D32B9C08A863D
+ B9B31BF35C520C3158C6861827E22FD8D616165692E28F2B98421CFE4BA588F6
+ 8C29B63C247331A390472E52763EAB6BDD6B0F24D23DBBA03C25977D7C98BEC2
+ E5A9171F7ED5E481D4FB2EF595E3E00FE38C2144C4CAA689EE710651EB470CF0
+ 726DCC0D9CAE83714E104C9235A3D5B6EFC9CFFFF98643BAF2BDE7B5CB5B3CCE
+ D0A9EACD72DB8DE6B774E5486FDF5BAC3125545D522EE1EA9567398004E4F5D6
+ EFB56829F91D0AFF2AC94683750384243BA2505351E6ECF3D1A6594F82EA4F74
+ 0EB9E804DDB4B43DF84F8B1278B8D78662CD312D20F30569D809EE8425F57535
+ 49D88A3FBD3A4F319D77DC79080CDFCDB091E129374872F588C759ED1EF579A7
+ 458ADA527FE3C5ABF69E7D00BA1E93DE98F62E50C370FB94B367702E56085E8B
+ B8E59C121A7D77EFAB37BA2A4C42D95A55BC1AAE495F503B983107FA1AF00FB0
+ 5C0188F552A0F52BB477D16FE7F89EB83EBFFBFFB659268D3969E31E13D0B413
+ 065DC3757819FE4577361DC97F0E6A965A5608DA0007FF2E469A812369BAC632
+ 20F609E8E8E9F767A86C5DEF5074695CE0CC0C7AF6FAA27D15670FA1FE8A512F
+ AAB16DF572097DDEA8E16B2018A78A500E2F31D21EF6810C5120142E7F69F44E
+ D70906DEFE338148707884C6102971354E756EFF8F0485F4519A06FBDDAA9206
+ 8DFFE3BC2069BD69B0BD5E0B1129DA858116D82A94502954D526D367C88405E6
+ 4902D89AB22758850CA354561832EA2A8D8E67914B2B33DDABB6429830487881
+ 269CAA8822A27FC4184435580F6049725C0362324A5C19C08FBCA2EF1F0712BA
+ CFC8D2D23CAD588BAA911CBEBF49E30401AB5624A711DE5E87AD6BFC8EE57409
+ 43E5FB3BF98B12E4CC0112B9F19E4289F1ED49FD142822A995F29021E756C052
+ 125B53AF50375AF9F953E0CD8DF99F70E2D9DAE621146B9D25D23CA6D8EEBADD
+ CDEEB81517A2A73F1068EC8D33FE729F32F6AE39F1BE41755D5A06794094BEDF
+ AD33AE675DDB4FE873ACFB80C5C92FE129905A16BE2F681923E63126CEB0FA45
+ F1AD60D7D70168837A20A299588F187243B520943AE5F09E5B47C7B208B3693B
+ 0CE5238BD40EB75E8FF2E107467ABC964858C7E3C7385442763CA2E11CF41280
+ 7FFABC87B637B2C4CC873B934C623A8E18A5D111011D3DA035D3FE19D6188DB9
+ A62B268A261C76F87F2183B63D4166E8495C01995A22ABF507E0B3046996BADA
+ 57FB65EFC9AEB2727081B22C0AABCF97716CA3CF1C513395FF244DA3E8AADCAC
+ 8F3FC1EE2BBB8422BBF2EFDE34EA3FF059DBCDEBFF04E5A49AC8DB69296E072D
+ 06D3BB8A767009512DF6AA56AEE03DE05F8C59BB2FF3F3D7F30D0C339996458D
+ C5BA894D3172CD7B06FAED9C908CC37F5EE1A0B974CB95B87E86D2DCF95E9D25
+ CFD48F2E44119D881A0BD8451A8CED51BAFF7A37F895CD0162A5AC28B951FD6D
+ 7B35C8C0178EE25C89079BADAF13E7DB8D0FD425AF744E89A89D30140AEDADA8
+ 29E9D70E32F03DF0706F90A4C37882528354BAC2F79F8B5A35BB704F10747DE0
+ F8FF59B3C53C79E99105B6A752D3F2F618AAFB04FBDC5BEE77B3D8AE5C4C27F6
+ 8067CA672BD713614F4270BC516E77136C4BBD2284D78C69C0120BF43E7A3195
+ 3C494576C76CB482D194B76E48885C266EEC98FA6E71BA6CF14A00FBDCA4F9B2
+ ADAE7FF0BD8FBFFA13416A026860BA094C52A45E821B590E4A8E519B6DBE5D06
+ 0CD15F84B93D2FE128237B1BA0BDEB7B5154ED82AA6E87DAF0F456B6EB7D3C0E
+ 32B2057701E554E83ADBFB1ACA5488DC6A86527DC6C52166B41845735B4A9AB1
+ 17D1F91D36E568EBD94037F7B12D1C629C0267FBB3D00CD74699A2367CBE1920
+ 7059D97EC4E6327612D55AD41657956305A6F222857092ECAE7C66C29E7A2350
+ 7463FDE179D44177B7327FBEB120881365355922DE29D6A216A0A5816F632C07
+ 0443299F69833C3748A81AC4FB823B4187D95FB4C2ACD3360B844110E51926AE
+ 64C171AB902C2E923681D2C7D3C919E9D11C89791E98AD46E76C128DD1B013A6
+ 90D6EB099237667F3016A8AEFA747C338C426FC6B8891A1B4CA1C7DE03268E95
+ DFE5DAC3CD05C39A44B5F288965BC38FC347045F9D195C663A2AE4278A788FEE
+ 0076867801CF46196D5561DA8F85514D1B27B7BCB1B66F9BD3C1655D008BB2D5
+ 2306C338F73743C3A6CECF9C2191E6782E36A408F3A2C557D44F9EC1B79E96EC
+ B53F2E821CD94E66B7514D7DD916832B42888E849E204D5BDA9B120969A15667
+ 550FD9FAEA73C0FAD28C9736969464ABDC8D140C5E96841D8FB2C1833B2F3186
+ 850E21F1BC5C341057334EA4B0DD17CE2D0BEF4601BCE5A669E1B9257F75A94D
+ 2160E1981C48A44689F103A6DBE55DD5804D38C2BAABB95E93FAEFC8B9FE2598
+ 96AB55E5FE7817F0561B1CA16C07518BCC3AE3F6AA084C364FBDCD864B7B35AD
+ 655A3B53D82D44596F6EDB133B613D08D7B8663C5C50802EAAF531EE286F14CC
+ 43677CFB227F8A2ADC0578B7B34F6F88D3809E4AA70D4A35B54620D8E5D2C4FD
+ 33AB306F92AB9E046744C0DFB8320D11AC86A38487BFFE54FD8FC244EEDD1033
+ 68991C0E1AF036F6BC6F63A6F73AE3A7D1BFA5F112C052F42BF291D8B6508300
+ AAA85E1FFDEF1CF5E690626440C50FB6E7DD7A930B1A115EFCF26A64548E9360
+ D5C173049EC18CB1B4A94B791C37D1A2B9F37D73B1FF664FA3947385EEC551DE
+ 159B3B4BDE9DED84D42BF909FD2740169B32ECDEA6CE230F11C3253DB354AD34
+ 67CD4CD24448FF7B6F3D240E7D771B3A1E1986845748791B12CFDD769290D567
+ DC025CC374326FEE41AFF54E521009EA1A9435B051FC6319E8A52D107ECA0F2F
+ 53257D25D5FC5F96F860DB84D9202B747661B6A1BF3737E6557F8C92A6653EF9
+ 7152D2122484549B3E709444F80D29191C5EBE4F003B07635B16B7B5C0784C33
+ 1C4CBFFAE9241B266317295A082EB0E86894DD293FCCCD6BCC2AAFE67B410258
+ 7F8FE6F821EDBAF4DD8EE5016E03CE03056C47F7E7EEB06007338877D5B38C7D
+ A12D13551FB76101C0AB00121B642EA36D6EF9B2A9AA304B2B337F83EB598714
+ AE348F1513BC35668A796EF71E01A987CD79C508DD5EF45949CA6BF0D8B93223
+ 05CA91F67C85BDF5A6F18EDB0AE856BB96C3E8F67ED4F895F3D0CE34A2A71462
+ F4DF58985200CF0AC0FB0E211E72E280F3CA5551785678E24CCB16BA199472D0
+ B9E2B4C9D85D60B83F27FB39D0B1B905CF4C535051EF0BFABBB7F22270189631
+ D9AB64A883A1C0CDF0BF607C338704227201432EB163D9EB285E70D01CB425B5
+ C9D00D6574E441F0D3A43EE7BE5DA9C4C8317B0F060F1EF602330CB3A04E9DF8
+ 493EABBB9562774148AC73731C98C3B8D2178E71C95C68AB33252C5FCBE99FA7
+ 102B16E65A0A9C0A42DD2865DED36E1BD21EBFFF3E8BFAF53E9515CB7C48B70C
+ 7928161655EDA14679E1B4AD4B015CE597778E4336FFCF7089421C2939978FF5
+ 88F2CFE5BC7DD68CBC58CC63B053EBB61426F2449146B5F8CDD1E78D7AF7AE67
+ 2697230D668FB324A6387DFEBEEE307D9944959D0C9F8234E326DF6073EFDCE3
+ 59D9B13D01A4ECBC039B17619023176F8B2CBBE4CC1BAB2DAE0473FC687D8BAB
+ 593D87435A56BA47E52FA57E135D3CE969925691657F65A15FFB56B1FB4BBBFB
+ 43DBAEAB9DF749C85D158226BBD3D9A480AFF4935002AE125F4F96A03C5AE5D2
+ 58046119D7A956693B2F32A4DBD2C57501EF1C8A277A4FD42347F07CDFD37EC5
+ 4FA6AFB26742671D66EB4A746DBE28791B6E63C25111FEA59E1A0F239A2E0411
+ 48E2773A491E01DB47D67611F40C4B3C862975C0A379DA1D15EF87A840008E02
+ 305455E6E13847
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMTI10
+ %!PS-AdobeFont-1.1: CMTI10 1.00B
+ %%CreationDate: 1992 Feb 19 19:56:16
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.00B) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMTI10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.04 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMTI10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 39 /quoteright put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 65 /A put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 74 /J put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 87 /W put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 121 /y put
+ dup 122 /z put
+ readonly def
+ /FontBBox{-163 -250 1146 969}readonly def
+ /UniqueID 5000828 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D5993DFC0930297866E1CD0A319B6B1FD958
+ 9E3948FFB0B4E70F212EC976D65099D84E0D37A7A771C3101D6AD26A0513378F
+ 21EC3643079EECE0C9AB54B4772E5DCA82D0D4ACC7F42FB493AA04A3BF4A1BD6
+ 06ECE186315DBE9CFDCB1A0303E8D3E83027CD3AFA8F0BD466A8E8CA0E7164CF
+ 55B332FAD43482748DD4A1CB3F40CB1F5E67192B8216A0D8FE30F9F05BF016F5
+ B5CC130A4B0796EE065495422FBA55BEE9BFD99D04464D987AC4D237C208FA86
+ 0B112E55CE7B3782A34BC22E3DE31755D9AFF19E490C8E43B85E17ECE87FA8B9
+ 1485831624D24F37C39BF9972D74E6EC4784727AC00B9C4A3AD3DA1C22BD6961
+ 7E0ADAF55422F22ACA5E4DCD4DF9FCD187A566B7FB661D0530454D0DD6C6C50A
+ 7A3875C6CBF8EC7769F32A1F3F7FC1C072BADEC97794D4E90E0035282A170402
+ 356E5A9CD9ABD80AC4342A5283E458A7269252F4541CBB6452B39ED54D336D0B
+ 19928E9CD1AB26AD83EB209E2EC75011A2643813053B5DBB0246097C4821B5F2
+ C92554E9140BE35B2DBFCD98809A8EC9FC910FDE9E0D86457C70ACB056EBF90F
+ 244DC0A5BBD455E15D6E3180311D52CF50B0BF7D0A7F64F3A1821E0AEDBC2E7B
+ AEB549FE1D51088C153799C6E089B5D5D65E1C4E2D2B430CDF1FFA23CCB25D95
+ 5C4DD885310A706B320AB25C8D742C6F29953254FA54DAAEE60ED477877D19BC
+ D28E9AB576B0EA088171FD000B60D73B3C57F754BC07EBC9BF751B7D2B32459D
+ 993861B7C4B0D98C422A11BECEF76F4EFC0ECAEE89723E6CED53E3678D733363
+ 2DF068AEF0FE7DFB57393BDAA439A6A4C396F86032A98009EAE1247B7DE83B3B
+ E46DF2898598FF5E6CA6953127432A967E4FD41CDD60D6E413059A58FA556EF3
+ 309178B57C16A763CFC9BEEC276944BDEA255789EF4E1ECDE1EA43EEDB955513
+ F42EDDCF39AE522A1DC2DC523F046EEC4CCAE25792B702C288732F5B13B5CCE7
+ E8B6A1A1DB86B1EA38883E481BEAB54023EDD9BB94E7780DEEA577ADAA169E66
+ AB7D8607B409619E79F242CF52E618AC0DAE43317C507CDB27EA8A1472D4E8D9
+ 17E62C98DFB049C78AD15560CE44A39581BD6B555165091C5D41071212A9D2E3
+ 05965AA02B8A67AEB04D915DADC1B84A531A1D672AAA06E9F720BA88419A3183
+ 63D1F9A3BEF8CB2E23CD1F9C003BD7849F093D3B4C83C153A5A790C1F9E37948
+ 5799C02F004C61A6FFDEAA1F9AE884DDD40DEB1539CFE3C3BE03C7C33CB54D56
+ 2C2A0F467049797B56D407AA43EE6B8C3F978A7D945A80BF711C12D6BFFA3DED
+ 35FA8B22E68BBE4FEC59E4C56D3C57E14995A8ADFA51CC6C3A84D3D775CAFA87
+ A1A0F45C0283139FB485B8FB0BEF5232494C0CB564F966DFE0D0566031392619
+ 3FE8F0BB6747BDA591DFB26132947872D3B209FFD838A17EB1D5047E39222225
+ EFD67840E30D31966C9AF01277ABABBBCA8A491A8FDD58EC2494DA00FE2EE878
+ 740A2E3403C528AA7A4303E9D4382DE3032D03967367CF7519E768BD8AED6678
+ 9C594A391C783B5DE9B85C8F673377F8C64DE2737D808C995B18C0983AAFA2C9
+ A23D61043A4BCECCE8FC1DA729303E41A4383FFE2498E12F10DF2334B479C63D
+ 71C1656BE66AAF0AC46DC1471E7390308B33F510D98C0FE5BF5C79817C03E1D1
+ DB3C04283BE4412A363343C82BB9A1B2AFDFB19B71BC8925E18E417EE2B077A5
+ A92882ED445E6DBB2B01A5177308AF5C4A8151FC6128117352FA2A2F8483821B
+ 6261292ECD57D9A5F5EFCA5D2594770D971A6AF96D9538EBA3DD5035C10D4612
+ AA5DD08F47355868DE6830EBB230615FE3100189FAA2CA879C5CE9782F1A46D0
+ B3F6494ECF62A7737909B31AC8437DFAB741F36093AE00B124737640A3FE62E3
+ 8989A8CD6A2CF81BCEB831F640B1266E1446BA63BCDDDC1D98946A8CF65D8C66
+ 0C7F4A38B59D6F97B50F6C0FDC69C3C94E22C89062132409F4B179FAC1D20AAC
+ 956AE86BBD9D2911768A144DA629C2DE7A081AF0689A49F12E2901FC58FB0D1F
+ 1C526CB95532F2FD7C288B2AEA7399D50C2D9451B4F628802A7906790F59A155
+ 1626804B2F411FEB3D26F0E84B599FB58B5FAC188E098550B7AD031F919DE57D
+ 25E21563F3770EA82A60434A7881A763C8B99B4D9574F1BCCC1DEF2670C3B177
+ CBCDC91BFB5020936119C705E0B4B1F81B0D5BD4EA5591527D36BC2FCCACECD7
+ 49CEAF6A244D3C32BFBB83043E42017D974D5A2FD8A4C4F8FF2000E618AC8664
+ 7A30A307560FE9B6A814BEDF4DF497C84E0DF4DAEDD816C8366565AF032D143C
+ 37E8795370E7E370CC6EB049F858EE5F049C45AE4CE0D4A948F8AE6D0E77BB02
+ A401D013E049243B782CA1E49FC16340BA20F9D7F8A5E985533AAEAC828E86D1
+ 3F773BDDB0E531284F27BCA0420AF066671D35300423ABB9CD45E9A9AA882207
+ 3311856BEB1BFE8CABE8FA22F58835BD3A2C08D4EB3E21851B072247691368EA
+ 3157C4F084A9FA14911F4A6FE27D6834141A279B6B25E01EA01397119C6200E0
+ 69EFBFA8CF043C00346769660DDC461BA93D2378774D22C36FEBC9ACADA9B562
+ A8CD8FCB6B0513B4EB33FDBCCE2DDFDF1315145E6EE6BE6559FA21A39DC952DF
+ C15651AA863B81A4D26D083D5DCC010552CF44221F99D38B57F99C24EE008868
+ 484ACF33D7ADB5ACB8487CF60838813F157763DB9BF70BB319D9AAD5F5F4C8FF
+ BD1568C0C548BDAEFDA0B56BD9BAED8A32FC2ECADE0A5E804343D163B7D72031
+ 4FD80CC52C81722F7F6DD9A8EC1D37FEE731C97B2907AED2F05B8284821AD4D8
+ 4841F7D0FB43C16773A868C8A9B2F804C029190C0685F9CF1673A04952631299
+ E95251F0A2BE4C85DDDD55A75CE176F73D6692A2CA7CE7F1FBF21B0C2D198257
+ CE69FD9512AE558CBC24264C4B35A4BB197A7AF53A1379BC7772D3B3033DFADE
+ EFC6AEB5601EEA5687BD5747818A3B16292AC6DE84108F9105D837CD52A02DD6
+ D0E1B65F95FD82C192FB8EC2EE976FD2F1C50081B3DBBD08952B3B0AE28CBBC4
+ 216804651AF9FF4F9E48593A07341082D13D212546A7B22A6DD2A54C89F4FA18
+ D449472761F8F2ED1E46D1FB1878092CED5F488D98A532126C81A381781EF8C8
+ 9EE631DD0E39569338A6629170A2754B8373919E3E079C02E7976E0E40CCBE94
+ 934994E264717DDDAD4BA431230AC99C07FA525BBC4E3E218941F52706348B89
+ 36BC3BFED69307014E5AFC6B1B7A4C569E4B9143921401CA2C88BF9178E4337D
+ 77416470406CAF215309AD37CB63581798FD3F5A133E266C44FBB8C52ECDAD2E
+ 59604001AC6924995A4D8E9CA1090F3CEB46BA1A32AB76379D9B0EC9B39F7D21
+ 49194E436A81DF0BD2F97201D1CAFC30CCC90268B32187E0CCFAC25B9ADAC35A
+ FA69A6B4EE6BF699824A3B4BDD1DDE9BDE51C59D6CF37973F10ACF70BC07F231
+ D1AAEEF40B4791945C514BEF2EE8A5E5F7EE6DBEBEF0654AC6319C9668EC92FD
+ DD8DCA68400827D232A24FBD0C1574609133D281A8A7F416BB3A5F7E9C7D9225
+ B8EF8878B5E46A18AA7070F87969E7DDDA436F48EBD2A5322D6544C44C67A336
+ B3085560FC4D5C03461E312B6B5163EC310781546053DF92FF149F9C43E01F26
+ FE4B1C9FB125EB5F5218A38C0F49C72FAA17264AB7589E27A53DBC1B2A39B4C1
+ CE16813476641AAFC15BE0DA0DF45D7F5D72E6E262683173C490EC65500EED88
+ DAF48BEBF4D7540620D34BD51F1F513EABC4654D5C8B7A90E817D27AABFAC257
+ 253CDE19FD3017CA1656E4599F27D78AF4BB5E3283CE5F48691136DF6EC29E90
+ A57D44272FA941A6F43F9D8DA3DDB15C84D3E7692A48DA374E4EB1963B363F54
+ C31834F74D4FFCD90102024F397C5A4A0C7DE35F4D076C8229C9BF963B62CAF2
+ 5548885CE26016B0F0F752589C0990369CF17B1F190E7D55A93FDE5020E68ABF
+ 5BB0BE644C8F66ADF3745C3BBBDA1E452FD136CBD02D240407312F39795D34CB
+ CD7198865A90C57070FAAB1BA3C66100CF6212D2E77F0CEA6818CECA39D3EC18
+ FE55ACF11605072756440454102751C28BBCE01F1F5A9FDC96F33AB94DF6559F
+ C38C3D2831B454D6BFF9D41F5BEE22E92B340C1FDB7FAFA788FF751481FFCC6A
+ F67A0E7801038FFE9D7381F9624BBE19F54A56B6166C7CC7E5332FC8AC27BAA0
+ C767DA69C16BEAC5304F771E84BCBE96A84BCA40F3A92FBBB791CCC2BC0AFEE8
+ 2F70184B6E23E04E195F9F40DC1723B9FD18EAFC273F26D0BAC1086B8DAFFE77
+ 316EDF84CF18D7B0C3AC264A28E5BAF0FF385F1D577D7119EE9AFD88C3035AE4
+ 0037AF902850896FA960A0F2075E89F8A4C6F457A4C965A170D45D9A3B9EBC84
+ FEF9E5A85B68ED60B4B0D69C3ED8FF9854CE46354D1A2E1517091FCF82260EBB
+ B01A517956933433B18FA3D82865009068B79E2D749BD0B871A0EA238584872D
+ 6B9E91522AB25A794C023B9FFA1AD5A96DADE381B64A0AB1E8B10F57DA61522C
+ E7923E489FAC94718FFAD55D1559F81792F9C65ED08D60C563734D6CFE4A5EB4
+ A2B53FA15A9CB573397E81D5FFF2618ADABF1D62A0672CD010CF9684EFF98A29
+ BCA3E0538144BA7580B6682BCCE774DB40C328DC400FAE80646434CA4E65D674
+ 5D0C5780B7D60501B3BD9C8111AA7E705215C5F47243FF156DB8E010D1A5DC79
+ 80E60F6AD42C4DFE1D72B80636C18E5B24E3E49A6DADB794C37CDA6FC859A59D
+ 936ACD5ED60536E2CD1B1D1E176EEB7613A83C699F091B00D5B125A3DE2A486F
+ AB836D9305A4418FF915599E9B2C677708FC09F83A25AEBB8EDF5EA0A7F8BA76
+ 7A3F99BB4F108D2EE2F77B11D0C80F143BFA9A544C3143DE43265F96AA8BCE31
+ 34EC382DFFB7FCF49D02AABFFF5F7ECAA475B2A23608F0E4EF3BFD886CF1B883
+ 5B5616263F43445AE044587067A39D0DABA2B6AC42201CD9336367E0A59B5975
+ 674EC50807A6014D4E793C26C3256F55EB619D2479CA1042EEED8F698CDC1F1D
+ 0AE5F78CED65B09B1E90C26A0DCDCFA37944A1B4DBEA54AD9E5F023BA4CF17DD
+ FC1FF0CAB57FD7ADC9468F262AA57638443CD5DE37D77358DEA306BEB02EFC3E
+ 194E36E3F43B5E37C422729533341EC99D062547F8BB286DC9D2D0BEC00FB73F
+ 9C5FAE9EA8C7F393F86B6FEB98FE9F91D7815F6AEF18662CC4054CB36347DAD0
+ 1A8DAB3DDD424522332511FEDAFF560F9D2B8C7E8DE25563A5776C0B044EC1F5
+ 0B3681732EB467A1DF8D4C8E644F668A2E4ABE694F9B94338BADA5E28DAB160E
+ 2AE49CC0BA503671CF75C53CCD3421087AB2F65836F063FD3E137786EBD08986
+ 2129429D1EF67F93BB9B6A89D9EAFC835B0473912858432E294093414B79B584
+ 56947B499BD257CD0D613BA12EF2ECBD83E8B60B0D38999EC3A345C37AF6E0E6
+ 296C54B7C6D4B3061D24A7A0C9BD8E5A7B6A3792E85562DCFD6E928B587EF34E
+ DFAB16C2C3E60558D1789DB407B3D920535356D2D8AD7233D58857225E32AFD6
+ 6E60E4C438E19FC6A1757F1C72E31549F138A9BF2769E97466396864BDC53A3C
+ D8491DD15BB0772DB671DED3F3725FD2E05BD1817018959AD916D3C39252ED2A
+ E1BEC1E0C38AA652A6146847C3E7F8A0714C3F5DEC0F852DDC2ACDBC2900C80C
+ 7684DC2DED260CA1410266BDE19D6D21A00F1B6F488FF925858976347AD628C7
+ 343CEBAD1447E013CA9A24429920A23A5927274E53B882C4CFF1B87ACFE71BC7
+ 3C512FF4535712F74F319178663DB076EB740D6C96EA3CCE4935DA18887DFD34
+ DD54BEA6D74E1567EEA92E69D584EE90E503FFD8DF92B04928512A32C9882776
+ EBAE8297A4ACEF467827186137A03CC0FB1A15CBCB23A51AA06B5B806E1AC515
+ 8819B83DEBB3144495FBD16FE26CD80D04B539750DABE6FDFD781FAA28776607
+ 8F83D159AC7A81629A222F21C7A63E0CA8F718754F0BAA8F32AEDB9C89E9F1E7
+ BD713F78CEEBEF4AD03D3754244CAD7B9107B195DE53300AC094E2793C24B370
+ 77242C4F6278C13E828A5F67DF61C446EE1E6FB300A0ED5DF38067C74D272E39
+ 61A05010B6681012DA293E7452985BE2DE03424F68D8C5D64357196A37A817D3
+ A1C1CC1554AAF4CC16F5D3D3C538361938D8291F33AD7549ED8157C8B017C96E
+ 344BBB3FA8DCD5DC6DD4CB78890D1659BFA93430AD322B8DE6157EA96ABBF3B4
+ 18418927EF58E7CF5DD602E7591FAA37CFC29F6767BD8D5479DB162E405414A9
+ 83024444F0CA02771012C5CDCAEE01692BB897E1416DD6D3A68D23397272A7E4
+ C71DB62242D443F5ED791B17E9353B406133472B8BD68879271DB7B47CC879C4
+ C0EDCE6074A4D29F1AF2C751D762C458722B7B92340C5E74809EE9DAE3A6B473
+ 650A2E621BA03624D8C44CDFFF8AF85BACB5E81F9787B5E63D352CCCAD3EC302
+ 56D9B47284BAAC7F9E89FB3A494DF5C8429F8489CA29DC3A99FE01AAA0162D1C
+ 9BCD086A0444461DCA3C907D46D684D5A11841F464C0311B97874AF6D2A6C0ED
+ 29EF5320CCC390DB981CEBD3B7AADF48CDB2DF6993881EF326213D433CE166EC
+ EF4FB9E2F449D985E762EC9CC75F56B290D39DB429D73463D5A8BA21A51519D3
+ 1F55BF4A45A5E234A1C10CFA7E592879BC60A58370DC0AABF232BF0231D9534D
+ 1DEA3B44E723F4B2DD67EC58928B074A167B079705B18954B56FB64F2B1137EC
+ 7916C2285C33ACDBE27952D3BA5DCF9F0DD055C9FBFD7AA3630920DF540B090A
+ 78892FB6E3CD5D1E36898E3754D1BDC264A3CE5890CA2B1F6F2C9E45B6F2BB4E
+ 3DD2A7B34B146633C7392A8586D5630D27A21AC5A5896905221E6E4D326B2203
+ E39DB60A02760551144CA1CBB768B1CA76A9C77105A8296F861A0A32819C75F8
+ 8DAADD74401291EF0EF751BDF062585D018C36F8C23442ADF57CCC800B267002
+ EB570BDD30929284C7CFE2D5C81833475F3568826FB6CD7DA875A101DB1B0336
+ AB1AF2E2DA858EC07CD0D251B4FC7F7DFBB014A442F947C7C19FD0A339E40FBF
+ 309CD79FE0B15D9DE19BF1CA45297F76F11394F5C821FC4FF703E3FC6972C84C
+ 03AE22FAE7098B32B4B7AA894E8F715C407686B022D82523B521B7D6E55F3A77
+ 1F568C3A8D998D64548A632D2D3420DA21D4F6183CCB4AC0C591B64C7F0AE7BD
+ AB5DC13394F4A837A8DF9A85BE9220F2E5CC9385042F71F69F53AD36429ABF7E
+ C4A027A989437DEEE9701CA6542EE94B478A47815DC490E17D64306DCE44D8E4
+ D9347EF3F4850DEFD8A47EFD723BC4BA46D3D7A658327342AC1BC807A152273F
+ 9483D6C6507EF87D065BDB75091FD69D906A5DE10B1C55A38E0EA360377A82EA
+ F51711679DEACA80D928C7B0E107AF204DB93581E2ADF95F3549A04CB4130C07
+ 5D3C86045B580F263D9A35FE1FCB9332DA622B910E47B3CE2CA2600061DD739A
+ E19B38D3890DAE62DEB3201C0ACDC5B55CDD52D8DCE052D1C79089C026DB264D
+ 7ABE59D7B4E593310E41B7BD0F2B211FC54B90B3F76DDB2C39A456CE76DB8C46
+ 02C1626907E038AC0009498F78D50F7F0DA7113DC848779E3A15C322F5046581
+ 359B7A6462621AE00807F1B522176EEEB83B7476D722D6E45E9330642C23D446
+ 55CF39B247826AC8FC512AD8F93254C06DDB0C326AB85D6DBC7FF488533465B3
+ E906B7718711FC955CCC8AB01BE70D4CE12EF09F4D1F8C3B7E5FBF184DC918AB
+ F1F1D22B0A08B1FBFA0337F95F3BE75F9F31890A0F5FF73B3F37A3DB8431718E
+ EC5632118254FC0933D6DDAAED007E5BA1A444E9492A1C3CA9E82113FF8A0E26
+ 4FE2D98EB15972D31233CEAAD632460A57109B4C56E4B67EA90AE72E8456C39A
+ 7717C41696CB176AFF86DFB1889357C4FDF9D34413645E9CD321DA91D65BEE53
+ 1CA4C3C2D1AF218E8D50A0AA1B92F14BF5F43ACAFDA8C7BD0EAA338065E73617
+ D8C475C46582527E7877905954E946A9DA7EFA1BD98E299385DCACC1CD3D47FE
+ 439651AEAE6262636E32B69832AC06152D06828A7BFB119B0A4E5311E0017F4D
+ A852F2A276B54B97B2444BE24BD36E12B38B38B500202482F712114E70BA2859
+ 05D5B6A5EB4C98CCC714CDB3C486213946862732666220A901047606BA208BC8
+ 99ED7EC929FDFA7D5E206C90097645B754A07A1B587B80D6612A6A16264DE6B4
+ F3885FDE9800490364221D3109875EE5AB645AC9DED0F8DE5ABBBABE1C5400E8
+ 142D7AA6E2B2A33AD0691BEE3637CE2679E5829E01454CFB362CAE127B1B7F0C
+ 6B3118889EFF4BF57B8BF26E5E1B7717F7D18A6F5BCFB2DE271E9638CBACABCC
+ C429C4D4E1F2C74F6DFB55E6E99560960EF9282C70A799B7BF0701E22AF2D794
+ B3DBF9BE32086DF6994A919068C08EC462E8C6E17C32FF0DEECD92FF2B1327C3
+ B64DB938474805BABF5C36C9EB4720246AE36D7362A2DDB291F1FA479E7EEC1D
+ 92053C6CC49FFA419534B34FA0659084144734396156B398BBCA08164D5D78F3
+ A523009A2F3C5B470746A7907FD13BB4B4A80D10FEF4065CC2FB72AE824C35FF
+ A02CA95835377D7962CFEC3791ADF1B200BC256B8851EB7CB2A1003137E2FA59
+ DC041950DB95E25CCEBF9C4ABED2270A9AC1FEC0B57F22B5F6494FA0FF10EA73
+ 52D5D2D97B328F0FCE8E4B904840F1F6939A663A629E01CC7F2A78FBF8D723BC
+ 5FE682276CC2FE552750E1404333F43793E6DBB948934FAB55CD7F8CC014FBDC
+ 3081588AF9A961964C56E09383C391FAD0D4A3EA4C22FFBF5A661D1C5BDD810A
+ 31ABD7C39A8AA72ED80558714FB0B5353069A1A952C250C0E037B92F49367EF7
+ 999B2F29827330786C2616B908436A28A1CF3281C4D1C0F1DA1C355E55351670
+ 4EA4BE01EC6FF5AE92A42440FF740FB60BECF1B02DC8C153054E1A16C015268C
+ F43F69563ACA78EC1D2B7354899F91088171A75D3F7CED9451F17BB16026EA59
+ F4A1D3D744C27CA2890DD0E891C570E976DE5B9F796E8A03AA7E83D485566DA4
+ 4AF2FB465738C5E94286E117BF985EC73999177E2312FFEED56CE412B6315C5F
+ 8F6621545CF0A452DAB074A80BA3D57A36C04E9DBEC0FA82377D7FB6369EFE93
+ C8E36E1EB855487BFEBE7E99376285572D5E30A590661A612B76F077290F41FC
+ 4AB8B6F41D0F4EE6C34BC097218EAB30212F1E3414E2453C9673969EFF352B12
+ 920FCB40B6C9818EB1E71186B8CF5B6BDF3BAF0E652FCCF0224D63A3C3F041B7
+ 22C94C7D90BABF3F50AE7C527C98763C25F3DC4521420B4A557F8CEE25228FB3
+ BD104DA6541EB23010137D1E123289F4EBB334926CBC665BA8BBE3F8FFBC0DA9
+ C5647547D2E09A197EEF07FCE4B34E4BA995CFCFCD78587B9DE401074CC3FC99
+ EA48B609E68E17F9A5530C21F734989B91D93B32C58F869D584C281DA15C5284
+ 17C8114D849D2742D1BF8ACE76F01D39C703C858EF7DDAD836DE2A57F27D715D
+ 5844565430D4AC2B80EE500913F47309181E5C92A67E624EF2A56B8A27A10BC1
+ 8C86C93966B942ECA874DF3BF1A5C5220778BA527B81D5CF4C8D280FD711AA4B
+ 9E1D2CAD09971EB701461D5BF51A2B1664B9AF445C172ADBAEA12AAF6FB0F2F0
+ 2F0781821A9192E1C8BF1813089E91B2B716586DEAAFE4F4781F1D1B1845AA91
+ D23A12CD30CB8B1DCF8E5E2C86F096386952E845F2803D0D8B692529BB57D8EC
+ A9164FE6F01AABF152BB47760D9D6B04A63051C4C744A8B7367D9C70A1E454E6
+ 3C399DDEE45FBE27875B4424A535EBC4A65F4E8A40CCBAD0172715A35EF574CB
+ 473C21514AEB1FBB7F25D0516AE4038375971C051F285D37217C7F36FE1B75BA
+ 57146BF4F80D2E1D43D23C36F15F5FBD5D4D955238E6006520AB17A9793C344A
+ 16C0E878FE0F93566509A09685CE097D738B7954D9383E4EF6D8C760727B9487
+ 1807494C2A3D69202557F09A9F5C003477E3B070894D265C1E137AAB4297BC28
+ B8FC0CBBE002A5B47365D7E2DB22A13BFA3091924929E20AD46626CB8FF24CA8
+ B8BBEF9983135890A2E3A95E3FBE4E2C99C6DA51311DAEB9711B56F8ACC9C7FB
+ EDDD22D0730F2C0DDC7A7386FD792B8EF07467F27B7813FAE59C6B2D6E1CB802
+ C314FDECA1B3514608423FE8B64806ACFC52112D5596A1346963529FB3336019
+ 3C643030DF7370BEEF8AC82A636683C39159D56C42D3CD0DD03F50927CEACB03
+ 419B515868B8A45D0A6A627B8DCA58081F3B437C7E456F5D820CCA869B828E5F
+ 1E93495440AE454BA9D5FE0104B24F6048E3C5CAC83B2532ED5E7253089B2FDE
+ 8EB1161965BBA540B3E9FD450D575269666EE3B2216919AC053CD6744F4DD832
+ FC4442BE05EDD57B3B5E2627C6FAD288881F416E0CA0A7F10A7D13AE8020205E
+ EF62BE8F1CE517D85BCD57E4AE7F98E26A5AA312313C8D21AC2EC691D3BC3DF7
+ EEF858ABA6D0AFDCF74D7FF345FBC879F125808FB175E73A7219E6C160786E96
+ C7CDD985DA4B5EEEE3164B29EFBDA440782BF0802BAC0EDB9E96F3997DF37A62
+ 52A3A06A2C1033313ACB012FCA79D221E2979A65B7CB9F13A1A8A39BBA7A0963
+ 6BA266D8DE7FE74D93EACA18F182AD9A30F65672C62353527AB95431C116C413
+ 0CB83964B7275585A34334623C2B6D219B6D793987849CFEA07A39627DCE2ADF
+ ECD538C3846755D02E8E33BF567C723AA6450576425A356AFE78A1DE7DA058D4
+ 9F046FFCE4AD5F32507A9530083B1DD03A6FD021E47A910B26139E25182D7112
+ 02207605F6C91C42D3D2163DFAF44ED0C38039CF80DEDE5D4EC638BF47D76A1F
+ 045A10A4D778C44A41A4C4F0336B3038949B5F02DA21BC436C149B3C8FAA17DC
+ 0745B3AAF801EA0AFFACEEEED086DB66692B2183B504880C62DCF266F07C26C6
+ 0B7F12F2F0F2AC9D0D4D79CCCAD71F13305DBEFA3509BF34EFCFB44B3DBCBD07
+ EA36F4CE52B7AA1AF881910986ABB45A0BA9553FBEED36458092BC2B60C133EE
+ 112BE869A75EF877D36E73833A7CF60D8569A3E2CFBF9B0F13DEF5B1662BF1E5
+ 77A941FD265A598100B03125BBFBA61CE1DA4D26600DB9E7B8C64EA80BFBC68C
+ 0B4369138AD4AD924D54F9BA5EEEE6F8B31F3ABA3A0F641427F081A227B74658
+ 38B16EDA56EBCAFA7772907AAE065C22E854F8979B842894946BD8D1F9C303EF
+ 3993385549FED97E56957E9DF020EF0A3A4354BF4C9076D00EB7B3A5ED41941F
+ 329A77107E5569B08411A00040F3699D7C2C828735771864EFC7164377BF069E
+ 84EE744D1F33225D76441576D9674A5224CFA006150B3ED5A92FC78C15890EC2
+ 79C71267B6B6E9DFA766DAC10591A0EA0C5CF3A94E53CB33D620C59700B0BD6E
+ 37766049DE2417757C60AE184D166C4C45443661EF5DE6C883D6C07D40B496E4
+ 2326517ED8183AF5732D057F471FA35B8A64A8E1FF16C5B37378EF1EDCADCEB3
+ 26EE9AC895003113FC6F8447EE6A935F76AAD6B80CB46449371E84D2812C810E
+ E01DE5BEB7885DB8C3C922A5B5A9902B33BFEADC618CDD33BE5D7D443FE9493D
+ ECCA3110BE9485D164D6121406C9768AE7B6C8EF6BE83D4223BB5BD6D1370D90
+ E12A1F573EB57FDB0E89BFF6BBF5718A58AC501B7E1765399BB983A71BF376FC
+ 41DA623E2B978AF2283A52EAF41B48F494C1FFF601F7307F4634FA95D5A4699F
+ D2F74DD25D4D466D6840F272279BCAC018C5D918D3FE42531080A4A18A23E53D
+ CA9D33E127247B242A6E0D324060C00D889B4A8C314B7237FD7E933336E00752
+ 44532A89997679FEB5FE1B470F0DE912A39AE8EF5AE17C65DB2800193FFD3772
+ 76295349909990FBC152A5CE056D85AA83BEC7430328B6BAFEB2AD6E89CE684E
+ 23662A0F96D4306C026B4DD6B9AA0252B2AD34908A7E79EAAFC117D9E666A5E8
+ BE5B901676BA95F04A517DA7E55A3222693EA1316CD3C8A0F0BA9C32C75489A3
+ 988BF317BBC003A768A59F6D70DFC9430C6DB41EC9A15ECBB3BEB5F4E3489E01
+ 985B8BB4881843FEDA64CE1059727F8363ABAB1ED1F5461F5C15849B8A780317
+ 3AEDE32C95304933B797354007F739B03FBC7C9CADFC6FAA41AD7FAF1B0135ED
+ BE45E77290130D0D4138782CF5B0BF409E55D92AB3DBAF0C649ED8B4E09F103D
+ FCD073C7191F1A2F64FEA6E9640298B93A88CEF5A9FEEB4C9337E327C600DF3A
+ 3C33F7129849DEF442571F250E28F32C2F6A594D3E569103EE2EFFF1FF8D224D
+ CEE4BF76270331C1E9327CBDA77FFA5006E25BEF13A758E9BFBF8575AB4643A5
+ DA17C36D5F66C6B4A7AE304281454DE395A0C8B1428FA62C38D0B99BC2071C78
+ 3C51AD8E13B917B2E28315721A77D4581252688FB95A9FA51BDE30554F964392
+ 540C7D5479C79DD247385F95F5247C22B34C636A0588C824A2DA035EE8F0CC99
+ C8E9EC10901C88D103BE26A62B8F413383583EC33527883BE31C97CA38C897A6
+ 3E8494C180794C3ADDA4581B265B54A10BD1830A225F67C88F6323D45B129D12
+ 213F0D02097A37B5C956B0B03D1FD93C50B9713BAC62D205447361A4FD2938E2
+ DE9306A0FCDAF0A8B397B007813A9ECDC5B5CBD8A19838D0B5F771E7E62CDE65
+ 86B15C55E5B232AEAC4765142C27B50C3FE9E97244C0600E6B14B163B80275EB
+ 5F8F7BCFB6F71292E03A28679A513472AB921315D1E2D790AB3464111A67F89F
+ 9072C93CDB773C120327D541C88162CED05B6CD8AA676E83E5DFF6A434C1DA27
+ 4040ACD9C88C8A95D2CA17A75109ADEF7B9D1C3EDD64966E01FF42689A9465D0
+ 517B3BA113FFF966D3FFC4CAB7453B5071DB14AD258CF176F64475EC98E83177
+ E4330A5729D51BE6168D88A5D2CD1C271E20A66ECB64DD006B07BB2236135A2A
+ D675504571D2BFF0EDF180C5169EF46D28580FD007CF71098E3AF74624C06CD9
+ 8FE6F1DD5E8A7BE7565EED80B4D6483C4788E1E329B9C2764418A25E4FF5A635
+ 8EEE317E1BAF3238F1913E58ED66B1EDB5CC22E52FDB134E306A55688DA33F9D
+ 3D03D8CFC9613C4D6C29261A46CA23E3ADEE5625CAFBD7C7F7E2F3D5BE8EB658
+ 66C26099BED47DF0002E0C929D75B35806BBFD85FF5A0167A3EA860FB27833C3
+ 4B1D1AAEAAEC63A5F4B5D593E963BE3DA8D9871BD6C265CEC6F9982F2A3D11B6
+ EF2CA1237A2A09BC06D5FCEB10D14ADDF54AB2FFF7EA1748EF164018D70224F1
+ CF100AFD877E14DF651F86E509BBF2FC28DABD21023BCFD79A4984243027B1C8
+ 9352A01C9FDD5F58E0040C363583724B7A728A181E056719236D89630A340D34
+ 31FF6041F32DE69E346DBD366ADA79A40B44E58E96EBF82AE767B32F35A0452C
+ 2F976F5C2EA882334A50D1B5CF65CBD003C465C8ACEA9C2DCD5328D64FAF4479
+ 7347314D3E21DDBF631D120714C75B239A767BF1DE119572CF1EE3914682CAC8
+ 367B84F42230E77175C8EA70B571834362F033688BC0FB1AFB65E2216520266E
+ 95946DD5101E97BB90B64730071C9571E3A38BAE1A99B9F7564AA03F34AE1F99
+ 43D5F65DF75885256CD6C9B615DA5CA1A83C9F7C398718AE5E392D6F2D764947
+ D059D01824FE1CBCC92D99FD97962BBD0FA0E4EA79DAE29AA93A2760BCDB680B
+ 1F529AF42534DFA037FE2809232711050F677482C8B3C3A465C4BBE2EE183DBC
+ B0564BEA379541304478EE51286A82EDB0BAD475973D7F3ABCA8F25A930CBE80
+ 956B0711C5EAE1294A4A0897886DF2620DD05D81EDC7FED3F5F878345A11700E
+ 33E8E2BFD9F1ABF7A649C5BEAD10C4201CF2C43401E614B34828826BF96D2609
+ 87FE307B0372597CECE96EEDC7DCAF3481422D0D58ACB29ABF702C9D4EBB385E
+ 9F528AF6F142B0421B011CB4B124FC5A7053DE07ABBE19E6AE17C85E9B707060
+ CDDA9767450FCE1F738B0398203BFDF1C401873A5A212F496B08A4ECB73ABA63
+ 927079D66959F978C236320F3251D5139D0B84AD39857B66DA3D65D27E234975
+ 6C12EF0525C9146B954EBF629AC939ABD906A6BF322191339AAE82505C2C3BCF
+ 208640E2C94189FB731D5935A51BD90D1C9876785FD8DAAA1C33D2E3B51F0343
+ 2F73DF7F72DA90CA5390BCE63AD768CB5322EA70BF4B99163FC55358E1FDF3D3
+ 2A7B92FC01DB86D495BA3DB8AF0B2FCE78BB1B15960E58BDE6F6C4645854CD88
+ AD977A66713FB633ED432C718CC82CDF9298300FA494FE498D8191B808D3057D
+ 23106076E229171EBE56C6F003DC247F44D98F503E0A4AFBB9494622BD79BDD9
+ E4A6D25D0A8A45B2374C1F8AD973FD0387C11E7EC00FDB6C1F7AF3EEA84BFC51
+ 2F151F1C1FC08A4200479296B8D5F9B7E5EFF69FC8AA4E493365FC93994C3E09
+ 8FC172789AA5E41868C2B547FA010F3B1B42A9B3969DA573D96A73A4EE49EA5D
+ 3975F44AE895DA8A65A900C8A55A9702CFE24DD55AA2A77FBEC06772EA7C2D7A
+ B9AFC2044A4F53F65DFAD1DA8338A9139CF9B0775E79C625C84BFAE67C441AA6
+ 2D688A488709EF1A1F2BE24E18B1D3D5E0B8E5853E1ADC003CAC266256699D85
+ 30866EA215B11D017AC8B99F159AB65C5B4087648552780BFC1090D0BE8D3A8D
+ 67FC3F2E73B768473F2B7E18F5D59C8E7972FAA3D760654C5702AEC28D762D4C
+ 7A144E43AE599FF06E157CE8F46AE21E806484EAE7C5EBD7265A6EB6B2C68813
+ 5B0BA75D46CAE5A8BC65F5D90908D973DC383B35DE8358027947605AABDB5831
+ 63E35F8D6F4157C9C5918258FE0EA39ACA1A43F20EFC7A17B46A5230D72CA337
+ A49962654C9A131DD7D83A508527E68DBC7F070015F248BF28560487F52C13AB
+ 1FDF782185F6BC06CA96D31EEE5B10FF9942DB5D5F866BC716E73536053C53A6
+ F93C396327664852E2E13BAC671A82E7A8D6AE54629920E26675AABABC9A7581
+ 76746C8EC6DF6E0ABA5FFDBF690BA5F37C11C37E8BC74A0F17A7154FDC24F555
+ BDC78354C4261907EAA27F689415147D95EF45DE3C26755728D9F513955F0DD1
+ 52722FBFDA3A7E80FB486F04B5EE6C5F5AFC7EDFB8235A9F93FAD6403F467A89
+ E5D0FEE66B35B260FE5F7C9D5C4AA3066AD2CFAF3CB9A2947DA751CC6CEB60BF
+ 6A530F94BA8BE5AB135FD9C95F103E3ACB35828B271B68F3AE13DFF725CABE9C
+ 7DFBEC276E9CDB27A231667D969B052D83FD57139AE631663C7344C698B82D8E
+ 2DD1575BA08CC09F2316EDC646AD806A6DAD847A59B6031712918ED344D5A2D3
+ 382BE2C1DC028B894640E94620F55D5760BB41C73280C6C4761BEBFC85AFC78C
+ 517D690BBF6F24076AD83C656595DBBA447F5B9360C23C95D25C048B205706FF
+ D8825D7E802E35812B50E3EF2997C017137492E8C27A1C30FE015AB6C6BA8629
+ 622C5B3D0C190085561C506ECCABDA05A646DFE02DC914382B55CD857AE4BF1E
+ 1DF34241273F4DB57A80B7E0B2C541D771EDFEF715C3D16E57A153692EC30BA9
+ 61CB1F55B55BBD1AAE2AF4F724A2C9BFF76759BECF03CCF0FFDC30B9588C7D49
+ 1E604A1830170E7253D68FE04F35F9338AF084910959B5A26D5D688A106AE3B1
+ EEB78F5D1A9E6AB4411970C5CA1E042A0498D52AE002865798034CAA90EDB864
+ 780290212AAD28F9B0B0E37AB4024114DBAFB063D75D24CFB97F14C210FFC1D0
+ 452248691711367C098418A44ED82732EE36B70360198F9A5CCAC6AAEBC42FA7
+ B495A8AA0D784D214E5F17CF21723F26E27A360E7CD67332891FFFE38B6DC80C
+ FEAD0F0D37B5D8D3F8D07FD1ACA42476E7968F67DE5AB10CEAE69CE9EA1CF2CB
+ 4C592510E0F50317B8AAE440D2B0EF983A5D5320DEE0F14D74508F9D1C9CCF20
+ 7E225C55F02E5B14A1EBD58D0A5BCAFFF387C2EDF1A1987C43E325271AB4E000
+ 702C08C0B3F32D752D3A50CCA0BAB4ACCBC62D5641EE2ADCAC90514DCE83BB30
+ FA7C2EC2CC7D1D0C2FA33A5DE7E56ED35EB9E9DA2DCA2597B14116ACFE6C78AF
+ 4DA5488E6B0067C7197CAE3CCCEE0A69250064CD1B7AEFB9F06CE1FDC20AA606
+ 5DE4B4390815E20A0B14762EF15E2F0B3B75B5C6D589F462A2ADF8E0957AD369
+ A8ACE5F72FB80E63DD2A882C7B68AD42E10E72D566FFE1A0FEE6145BC27FB4DE
+ 68E57B1DAE8D52820B95EFCD8BB0FC1A8279EB6F06735C473664891DF49E495F
+ 1C53A7D248988A3A9B7774B9FB2BD71C2E492D4DFDAD6289F1E72A637CCBD4BF
+ 63ECD65B4CC0C1A22A19D0739A9A2B3E02F2CCDB1C4ABCB7816A8AC746DCE2C2
+ 423DE9E59FB1D270A43C608778E5EDFA05B12297F8F5368B52C6BB8E52616B41
+ DF9289AA69B3FAC243FE969FE98916684E23158806742F8C2430674861CC2702
+ D6C0C86AE168BA2CE29C5ECEF022466596F4AB355B5D406E80A00B51379F3EEA
+ F7FBB41ED2DEC9F86B791E2EBD7ED6F177CAC0006F7993D350E4BD757B62BF69
+ 0600D14107FFE8A5C94684C996901122A459DCF92EA8EC870EAE7CD62EE52CE2
+ 16CC44CE33E14E08CB81B989CACF533A51FC98A57E90C162865BB84C69AC7846
+ 64ADA57EBAB06F6948285C9A525E26D3999DB7BCA3E507DCCF3DE29DB82EF9E2
+ 1385A7F7F03DCCCEFDA474AC94E9B1CCC5613D7565D183C645F44E9F07D6B415
+ 4BE99BAD3BF76B0A13FE019616DBA7D6CA07B962B7E2E39E49CB9185DD9C52CD
+ B37398619645846DD46B75AD0770F091766E811DB694A8777946D5654B3560D7
+ 04E9796408FDD5024DECFC718862DA389C3F6297EC45A6A6D0DAD69813C6E575
+ 3D0BFE0783A26931FFB95ABC54EE1751A84B9D915B3DFCB3F49E256442CE3879
+ 663F8D3688FD01E4FF09B0F7D3069D26091D34BD9E2041A1A1C34CEFC09AA68B
+ BE13FA6440E0836DEFBF5CA74E1A4E717EF14F4E4AEA467F1DA9ABB501171995
+ 3FD7EDF13DCDD92C94A9C7AC4FFE1F47B3E11CAC2C8D078BFC22F4E26C734DA1
+ F52D04B57D80B68D736A320A78AB6DC3E80B211FB834E332E4C43FEBEE92EB25
+ 2A2BD4E64394E7493C0B4F54AB9EDAE29ABFB271CA9909626F79E2B642EF7FCD
+ EC9EFD54DCB7EE43870FB3E0D70D5A288B84B4F16A399F7AF98703515E0898EC
+ 7496E63BA4DA0CF73D798C0ECF3B02182649920AA51FE1D0C9DF33E8CC6CD774
+ 2B383D2712E1E301D2DC932013299DA5A8296CBA7372C785B913FB34350DDAD4
+ 4539D6C999B5B82ACB634896C3620BB1C59B264D14939471FD0AD149F4778143
+ B53BE66C649D5401A4FC4121B9E4891FE3F4659B50798423A60DAC6E5393C731
+ 0A21A4D24EE6CB5F2B58E800DB20A1D1C22E8B4830002180F3D924F0FCB80AAB
+ 607E6B207E387ACF8B8E97A302D60B7FF6848B566CF26FB35135B3D1FB84143D
+ 8621CC71E4D0FBF05A02C55E51491EF0338AEE6DB237FE590773FE98EEC359B9
+ C5340C0D95185D37042BCCDEFC2CF20A8062E7EB52A11C489A0CBC833F149901
+ 4DF7E35EA1F8E3706CFC573852476EFC8EC6DB5EEA1FE7FB6C8C3F5488D9A052
+ 07D751BF2F766679B4194EABD86655FA92DECA1490DB5D2AF0DB24C9B8C18E56
+ B98706589A941A8B353CE515ACCBB61A2BD82DC2A8B83797772382700763A282
+ 3D5481066772E5323707DDFEADDD07F746FC832F49E3FCBFDB270076833CC6BB
+ 61F6A505F3156D2D37E4B20F007C47FBBAEEE8FBC965555A549221BB330340CB
+ 76ADC5A27EC257D67D935483995634CDD46C062A25567E35
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMSY6
+ %!PS-AdobeFont-1.1: CMSY6 1.0
+ %%CreationDate: 1991 Aug 15 07:21:34
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMSY6) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.035 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMSY6 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 50 /element put
+ readonly def
+ /FontBBox{-4 -948 1329 786}readonly def
+ /UniqueID 5000816 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052F09F9C8ADE9D907C058B87E9B6964
+ 7D53359E51216774A4EAA1E2B58EC3176BD1184A633B951372B4198D4E8C5EF4
+ A213ACB58AA0A658908035BF2ED8531779838A960DFE2B27EA49C37156989C85
+ E21B3ABF72E39A89232CD9F4237FC80C9E64E8425AA3BEF7DED60B122A52922A
+ 221A37D9A807DD01161779DDE7D5FC1B2109839E5B52DFB7605D7BA557CC35D6
+ 49F6EB651B83771034BA0C39DB8D426A24543EF4529E2D939125B5157482688E
+ 9045C2242F4AFA4C489D975C029177CD6497EACD181FF151A45F521A4C4043C2
+ 1F3E76EF5B3291A941583E27DFC68B9211105827590393ABFB8AA4D1623D1761
+ 6AC0DF1D3154B0277BE821712BE7B33385E7A4105E8F3370F981B8FE9E3CF3E0
+ 007B8C9F2D934F24D591C330487DDF179CECEC5258C47E4B32538F948AB00673
+ F9D549C971B0822056B339600FC1E3A5E51844CC8A75B857F15E7276260ED115
+ C5FD550F53CE5583743B50B0F9B7C4F836DEF7499F439A6EBE9BF559D2EE0571
+ CE54AEC467FDC60394336D84666336B29652E7076462DF70C6087A99A89F69C5
+ 887D9E651A859D64D64649A90837FD8FAE50336E1A69FD1B55B3FC15A80642F3
+ B6DC7AE39CE05B80EBE2031397C75759FA201BB78D9A63F539C2DB47D8A215DB
+ A7BD86A86F74FE9CC5DA6AF8E35E75815E2DFCBAA3B3C879942818DA1E884AE5
+ A257826EE787C4AF487B9E3645FB1763B2D83C7165666B3E63303694122477BF
+ C4F7A7570D968C2B5D7DB6251125B1440B6E0E74FF49EEF9D6D3CFDCC7A02AEB
+ 53EFD2FF61BF1E9254DC034198C94BACDF6EF8A2890F5513840B1B32E734C5B8
+ 509F254CD0F211948F13252CE39236B64C66B7D6CD8955F744A43EA5247BC134
+ 20B6A2DDAED0FD34
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMTT8
+ %!PS-AdobeFont-1.1: CMTT8 1.0
+ %%CreationDate: 1991 Aug 20 16:46:05
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMTT8) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch true def
+ end readonly def
+ /FontName /CMTT8 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 35 /numbersign put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 44 /comma put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 78 /N put
+ dup 80 /P put
+ dup 83 /S put
+ dup 95 /underscore put
+ dup 97 /a put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 104 /h put
+ dup 105 /i put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 120 /x put
+ readonly def
+ /FontBBox{-5 -232 545 699}readonly def
+ /UniqueID 5000830 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F0187316F83DDE3E2D27FCDF6C5CE4F95B6EE
+ 3317BD91B7921F3039DD35FEA387D5CFB6C6E9DC84C178F3432994FC7FAC6E5A
+ ED41A1E2EBA350178FBFEB45944511731BA827167DDAC238FC69A5486B995477
+ C469E2E27493B0B711DF8E267D3D5613B450011921685147114106C9472580BD
+ F531022F6DF5432B2A4EBC51A8032C7F9689B6FA942D849B29709631613DA68D
+ 4DF7B6F059A19304F40A3C3580CE3B51D79D42984194D4F178801720892FB6E7
+ 61FF43C63F9256B5E9F4227B1378222BAAD4D52C77462DF01892220E11129C16
+ 6C9E45BB9F01ED7C1AD5D8B4D72BE0E12969AFEA90FEF170603CDB91CB243173
+ B19A56084D10293B80A35275F41BF78A054DDC98F4A1FFF592463D944960FB31
+ 6BE5F03960F9B1F213CBCC7FD448657FE388F10104D42B0715FC9571CC60CF23
+ C72560CBB8835A0CA208FE06676B3B48B093CB7FB2C0C53AF17EC5B372A9771B
+ BFD52FFB7062B4FE0106A01A2A1A1DD4EF5C8C7623EC9324A2CB3B402FCC1FCE
+ 52BFC8662F8A39D5F1B41C97E7CE34E16AC28A1E94007AEA7D4C519399F1B7A9
+ 48FA7DDB671067244F09C29F95DD60668223F45BBDA8B1C452E930A9F3F341C5
+ 351D59EA87462FFB30277D3B24E2104D4AAB873BB2B16DA5B23BEE25BE2C8128
+ C4CF2F4F438A4E520CD932BAC455BF8775C27AEA6C73EED3EB2F8DB5E356AE27
+ 41B35C8AEFE73C4CD6A591AAE4F45762EBD6D3636C03F08C552BBFD0A13D11D5
+ 491F8369B4BAB8ED9D6F1DE7DB7AFD383986C4338D3AA71C9AF2B8A0955CFD86
+ 0345F16D9798B25156DDF826A7CB6A0CC4CB43078BEBD3E499DA95562A08EED9
+ 7CA27B7A0CE3FA7EBDAA87A600FC941AB61C5F9164B8EF98E854FD3AC7E13BD7
+ 554B33C4B9669588F67B2A61649F292ADF5E9C3F298F53FD220DA430C3A842E5
+ 6747916F99262A2C98C01443F265EEDE142BFA5ADC9625CB8F2120D33A77E25D
+ 7F2E9FFC0076840B2000CB3536AF2B64FB1BCF1AB36E05E4DE2C7B4F1955F79D
+ 7603ADFDC561D9D2410FA6F79CF36D2E15429448CB71D5DF668F0F107C9A6355
+ 02BF5588B9A85122F7B6B2487769B898B8F05CDB406C84615451F12944ABB938
+ 6C8432C6419063A08ACEB413556A05AB32E842014582C74FC1F2727496138731
+ 6B6F0F261CF91AEB0384100226C6CBF25FE3BA9647EBC1328AEEB7B34014C0DB
+ EAACF40C05FE9FA016397197FB4D90121D9FA08BF104D68821DDA4E692D95924
+ 87F8A28767EA1C03EFD297A6F0C70EFF737C015A398E8F3F36732883F2B70591
+ 4F0AF90A7A899B432640C1C73E1436C90A23B17C014FA32FEAEB9D8DDD0380FF
+ 7C236F4488E306D5B32198FDF1C4F1FA3C3C3FB868772805AAAAD074B576B5BA
+ FD8950232C7152E49CFE8550F323BE1FEE9D28C215F44081F45050D0BDE4B69F
+ FCA25C62C28419FFD763072CB2717C998B29BBCFDC46CE109F7D4C262F2FD43C
+ 7D65E327B578F7C6E01AB9DDE78520B78273D4B546F3F10E0F7F02D909C0D097
+ 740C41B174270714B11B66F378FA3B6B5F534BAA87FF41D01982FEE01C972C98
+ AD78D1413819EE0E104FB986804DC4A728E0C90C547B09127837DC0A597F9ED5
+ 48147B7BF29D8B7942C5D0617F976A92E654EA150D9976611075D2D6B2140C00
+ 42633C69E269D8AE7D02CAF79698F754EB5A6FFD83C97FAD35056C21A6D9FAE0
+ A01586D9DD2810745EC3D2743392C7DEB701B9A16A0EA4385EC1C3325CD046E5
+ 4FE544C948F4C88EB3951EB9F47B19A36BCEE44CEB39251AB588EA25EEF86CA3
+ E24AFFF05AAC52DD1262215B2973338711AE92A4AC125BD573A927591E5DD86A
+ 008E336E24185044AA4B08E91EA5331E5EC5D392F58939EF5E3D5E4319E38DF9
+ D205BBDB87023CCB6737EE15D8AF690F334CE190EEAEE2EC145ECD7FE3165A2D
+ 164E6BC3452F28A89B112AC3231D587329DD5727D860C754E2EE7F0FA5DFAFA8
+ 8DC8205F20F8F84735C6877F335BB3DEFF78613DB66AA6537985FF8EA4921051
+ AFC759E4E3883C0E6DD2B744AF0AEC9A20861A4936B4AA9EFEE23C97ED12968C
+ BBE9596BEC47B0D4EE2EBF2C509902AE2B0D76A35A910E4C07D1D48731CB25FA
+ 5E2092256C27CBCE0F43F364E89E5B28D9FE66E998B99841EFC36DB6A910317D
+ D27C902127797B454B9EECA8B0566CCF9D66E0F8D667D62AB9F44B4D66526092
+ 3E74FD9A64FD372AA1593235624E62025C7E79B91F6971678EA976416AC2A389
+ 9F08F7756052150F100A235459C8563BD24565409AEEA92FC24C5F9007930E91
+ E2CB3D0EA672661F384846A257CF51A95F137DFC2F2996241EFF21945D4E7133
+ 81301710D941FC55013FF3E2CB8D7ABDB4C5912139D33EA3FE17A1DD451DA2D3
+ B3213A35FA2094EE376254DEB1A5AA83E9227BEEDA1C1A53852FD936D7AD0DB3
+ 0AC24108F253F39AF7197EAF402F6925E014A9C6E70388E8ED99F6D2EC483131
+ F3070DAA4357A2011DA276A4638369E262305AE190D28C6681231AFE35035FB5
+ 50C9B69EDC752634C085447F517C69B4984D71932E8DC1A89D625C1215FE25E3
+ 1EF684F633B2C05EB78AA2F7805C13D7AB2A20CA7603B497FCC3EA3E9A787B49
+ 4524B511D948A04909C5D4D441AA04D11C1DECBF469C8F441C75B8FABBA9E95C
+ C2EFB8C2DEE6820F11B041674502F206101FD879DF9E2A4A0601E273325DCC23
+ 3A95F735F33B9A49F96953D18AB9DD2BC5A2797286B16869DB0F3C0D0CF7004E
+ 4C4EB2D0A32EE57EAF8EC6101C3C7818D74AF7A4BC14469D6161F76453B4D7F0
+ 6146EC3A161B620FB193551B970063393ECFD54466F5461F5CA78C2A4B3C92E6
+ 64FBF4F4F5B2D515651C5EB9E2D86E7F367C5874026A6B9E5939BF46ACF66FB2
+ 860FA06DB94716B6819D62246C65E509FFB50CA00E5DF925AA1ADB28945D9233
+ F7688C71BE6472E8F1633C3BE51399D4DA575AC8EFD738EF6C66511B8700CD48
+ 89A6EB1255DAE38BF50DE00BB01F40F29CA6EAD134A74E950339B5FF8CEDDAFC
+ D3992878D3AA3724C31DE1FD09707436C337746ADF3F3EB2CB42D0896B4C4394
+ 9EBEEB55ED897A8DA30939D72B17DD253C6D0922E52D74AD8FDD93E7A4040026
+ BCD95E977ECC10618B95EC43070571513AFF2B7B8CDADF52E79607AA8108FC88
+ F5D2F05AD0CBFAF84E2C42605638032A4B82DE1734C91020FFB1CED650599E6B
+ 9B8CFB6EEF75E987754C4DE53AE68790C19023123E8F564B98DB76ECCAD3FC37
+ 9C5710ADA3DD6435F9D7DA721F7EDB383AC9CBFBC7FB3BD3E197921F0D8B14DF
+ FD1E707F1AD1A763B622620854E9AA4CF452444AAF5683D47A14FDC3780B26A5
+ 846F8059EEE48068BE23F436EE13488A82DBC873473E666BFD35FDB82BCF55EA
+ 035BACF777CF5B9FED931CC3AAFD91A9D1933B1D261A241DE6D2660A16DBC0FB
+ A94DC3FF70F083FFE1339D9D04E6A47391D550937B1CEF91E5CD70509BFBB593
+ 5E8602C16960F68993FF6F2E3D646444EC9788E98535773D6CCCEFB60FE4D88B
+ 5F15358F1678A1CA9DE0ED59BD9B52F84F220C184AEF9FEF427F5FBA690D23F2
+ E3B0135227321AFC58ECF760527F0F5696553769AEBCF366501D85CD00518B95
+ 12B07958E8D4EB7A3453F37B4E6E526C3CEEC2E84BE75086355B7677D023AE63
+ D77691D0CEC85EB0AC0FE37031D5BEDBB7B3D95A5348F71219936DD2A8CDD94C
+ 4112C8140A0AF552715F1F974A801A836779EDBD5A5147F02DB7AC2F938420EE
+ 9F9818E862AA195DFB8E1A10A78B0FB49333E56D924CCF9852F0914032068A89
+ B412C464C66BD1D88236AA0787FA4D49A9043F012E97987B2A0602959014F595
+ EC4844F9BB207A299F95ACECBFE527DB2FE0C44A1C4867D23E0F5DBBC54B2635
+ 112DC29F7AC11855175AE82B8AD499A2E8F926862CA523D1EDBA348F7B523981
+ 095A7DE51A082021BD4696C4D08DE830B63DF8935CD36116364F0A0C1AEB958A
+ E73EE68B0E986DC32C5C590C11610168AD0F418A44606F040DF458084572FD25
+ 9CD71D2B5A77EBEC85ACC745C62BD6A1B0EECA422D2587255FED5DA542BB674E
+ 28C5C27543DDE8DDE1874FA793373B9BB3911E856725CE8826B20C0590856A21
+ 7FA05F7082AF5BFC332C95715CD300C9B8443F29BA4BFD880376FC5FE699B4F2
+ 8D59B4DADB70D81A04B83C8975835768105CB0DA40BE18606C5F1C7F8C714D21
+ 066327B432D1B248A818A3426711D53718E93A5CE38D2DEE1194FF899B6B5A84
+ EA5BE75D4D7D187E998F798E8BE74C83822A670B9961C353250CEE5FBDCD8772
+ 50A290C3F726713F9611835B5854BCCA974B77A22DF1E51A295A7E0758BA2E63
+ 0EE001EC07C7BDC6C80B3A61D13D657125EB191260D33D0D639F522FEC06988E
+ 009307F2A18F00E6B8B1DD13D33DFC7A32A1EBE3305D7335BF4107BA2CD45ED9
+ C97DCE184B6CD11004C0E3DEFEE962392F88B7C2F9F9EE88A128C25B61166166
+ 994995A648911ADB6BAFDEF8384FED8B6BCE2404C61D7FD5F3B5534489C337C8
+ 4F2381541143FFC30B5000A64F04F4F99FEC46FAAFB8F92EA9F887A2E9E168A9
+ B6F040F2916C11A7DFF7F506594CB63165B65562DEFA5D62E8D1E704226DED9F
+ F9FB7ADF4E000952C01BDEC089BE40E79E860DDA88276E8A56D4D9BF8F1BB3F5
+ 1A45287310D10789170196132F5EDC9D437766462EA7A4DC330C615C461ED864
+ 0CE933182875FE452A40B6A9E73FCEAAE639944CCE294AEEE5649B18E0D82E05
+ BADE0B39D8064996E37207112D684FE3B83E419C0B4FF7B98C38FF00FC6DEF43
+ 66B3925BD36289CE2A89B6284588CF6DDE74FA9712AC5A1509FB92D16060CD28
+ 3CC7968824BF03A6DB677DA994F7A68CD874BD805C04B7FA1A601B9075626527
+ 75499D7C5C45AD6BB9878649E7723808FCA228F240EBE3A75B11D2EDB2D113C9
+ 52E6FF4519F4665F8DC5F9DE87541686D546940CCC10956FE78058DD2A33C19E
+ BA74511DF779CBEFCE264A2CD99689902D122923D519410BA3263FD76375053B
+ F37A3414464F754418A4A8409D8F82A2F219088863F879EE4DFA68B393DAA1B3
+ CAFF19B08ED4DE09018368C25226B95DE6963359E4C1015775ED1AA6F13B8102
+ 7F02133E0FA3166A34F0A1E9A31C73FB3BB5DFF3E1A8C5890E8452730AED002D
+ 73D595CDD1DB52CE9DCA192F1587196E6D0D2D2D01F2D0E86B63100CB8BC6D4B
+ 9B6483FC23D474951DFF1973BBA2C8C12C5DC8785B97315E5A1460B49A9C3054
+ 661C389FB00786EBC73BADE698C3E49DD8EBB5A05990B7C2ACD283799425BB10
+ A596E6AE1D126618A2BE9B6C7AC4D7730DDD3D36D56199E0CA54AE43A8304246
+ 28F1CC19845026A51BF86C1A91349E8E93743AC0B885BBD4249430F1C60A3352
+ 671E5437E7320204E79086D9D9CD7770508C7A9FACEA4D69143F700A49636917
+ BE6BC6D70619051753D64391E474CF58EBAFDF3F816A7DD6D109641FECD31E8B
+ 434A65FE5CD4C53967B550A31030BF0710F098F3732EAEE5B7FC96DE32A766C1
+ A927778E6296C63B76F8EEF1923ABC8D84AFE5B7272A7CAD7AFCC5B8205B03A7
+ 8FF1AEDCEA27B9EAFA818E2870CB690E0EAA1AC12738D34F3EFCF5915165914F
+ 6812CA82C90FDAE3D53472C767D43F31060568F4A52051E770D66F770F11CDFA
+ 307AB52D8176F594EBB01087F87E57EED458E8F3056273F08A5800D99A6B80FE
+ 033538FAD2E9C5226E6C2308D5DC3FB16CE790B603A44DB5E0B11DE4956FE2D5
+ 6D6C6CB63935BA553586814F447CAAE09C361EF1DB3D59E7036AB18EC7864AED
+ FC6FEB667D20371AECEFE4389774232C7D4E1B37CE63CC28709CE834F1B98D4C
+ 19C02CFF2F49FE110A4B6E7DAF85EB00621A0D945057DA24190D1EAE6691A249
+ A76A67017E3B954B15A50DDC0EFC9E9E89FE18DE7B4F2064CD72233901AB1473
+ 181C7877FC26382F85F380D81628709C602D31ED5C5D70D0AE8DABCB87962C50
+ BB8F35543521D623397BF065778D1C2599EAF2797FD76A01268F31EAE803FE07
+ D9FD913E19C40110586DCEE2BF447D327AE0A8C2A28A62065752F36C9199F55B
+ 06B5144AD5EB7DD5DCE85A3F959DB27EB8B9C22C8B456E062E5A8C80AC4755C2
+ 83303E2B878C63CD31270EDC8922880B6E1414547588492D78ABCD0C1F4828DD
+ D85B93B811C3969F68A8BB2665D2F4EDD63F2B72D9877BDEC3A34AD83D6DBDCF
+ 3354CCF78799CB35F39AE923B71EFB784A89F6BD974D94C8595BD587B764308D
+ 8B04F412B64E04F33B070BBBA26046A488E494CCDDE07273C8E8E4E995EDE443
+ FD535DC49FE4B20DF0078A246B9B3B41D6C28C66DEA449B0449B3FF969608783
+ 595923F1DC56E7B9F6E969EC8F997B4FBDE3FB6FC00646D607A445AB340A92B1
+ 3A0A995F3935A684E32C852B613063346D0BC731A762AC3433E5796F3123B53C
+ 337676271CB2D41C7A75809CE20E310D28DC4CCC4B2663F912C14169067DB197
+ C63E03BEB8217CDFC30A65189F65641022349D055C61AF689C327B1F7B40E5B3
+ FD7F670A5C988BF53E830A6EF3C2BD8E41853C3B6BF445B36584253D75F361B3
+ 6D7042760C6353919B9354593E5DD361BD103B09A7ED72C5F3B7403EAB2B2A61
+ 452622DC68F48F6C372F96FDFE3C62B134458F1E7EBFA77B575935FC580339D4
+ 9841685B773E1FCC8C4BFC0D40A2ADA08E2BDD38EEFAC9ECE6DB49ED5CD610D8
+ BEDA0FB642CAC4AD3D2391669AC73C1A68C8856F9931D88E3E868E58598D3180
+ 696DA4F4A0797FE9BE82790736403D2C38555E3DBB0212BF5C26B8E302B5B2AD
+ BE4EDE5428664FFEB20041FB55C3360104B14BBF10EC76469A3F294610F209C7
+ 891223FD353520B3355C8662371BA434C34793DDD1682E952E1059F0C54A9DDF
+ 5983D1B9E26597CE835B94A58FC86AA52BF28AA4911B5BD21443ED31BCC459BC
+ FE0F93BB198C0D05864D9E6E00E8124F7711C2CE7AF96F357A8394F2897C575C
+ F9B3870C47DD51F472352BCC694902107DBAA9FA893F498D0AB3E2CC6F633BCE
+ CBB8413AEF9878F8C34A541706C51079F2B921DF238EC1C06F65A13A2597AED3
+ C149A12B07A845BE7D8F55D55700B84E04DEF04C1FA40FA089DA9314824AAFDB
+ 3B6010273B7CB7ADD089AF13D21A3A0E20E93C27F8BDE0A20288BFC00072D5A8
+ 08B251AE5A5343581E2C4A5714DC1CBC3BD9057463C96BA7833D3854F31F0769
+ B7FB3ED8B13A8FA03BE04A6458214604F4ED11E17917DF8912EC4C4FFA7C7AA9
+ 4171AFA2E78FEF86761E3E29923EA5F738651EECC758E1669B2D1B90CC41CD65
+ 792BC3F008158E9C7D33103D0A0393DE52D45DF17033E05C53D7F536A15A82E9
+ 564542764B5A4BC8746BB01420B4A3160D541FDED2D0A3BBDE9C526BB1F75450
+ A6C2D00AA87AAF2EBF5123CFE312A39185B5C8AE1E6607E0F0CB158A0741E5BA
+ 64DAA62193B461E61444CB35A5C563FADE1610CAE0C96165F19021A6084D4DF9
+ 3373B8CBF08D142FFF72172FE30492F6ACA2B0EAA5D68A3C4232688951D19779
+ 7BE024E2FC1CBB730D658E8307623FC5D9CB7307244D0AF1A359C9CD7FAD38A5
+ 1CE56F4D14788195F4DCB5982AB39DA384D965BCA672343AD4B136B9C5F66E1F
+ CCBDDA9F68B6661FDD436BCF1A89A191EA085A3637D3B7D0EF213C8C8AD41BD4
+ 4B65F245C344F7BBF142428DF98529697318FC3C08CA488C6762DD80D6B30DB0
+ DB2B42B6B33994E2B037C88BAFE43C1803691E9A8939AD71E551BFDCF47B2E72
+ F9B113AEFE4EF18B5B17FA2D96FEA32CC0409B6454EDC4631EA0027F1C3D8A10
+ 50A7E9F3597049A78DE1C48B86D271873DAB363873100CEE50D6772A1913C8F9
+ 2487C6AA8E64AE83471ED26EC8041EE4FC882A13111A32A1AF452F866E9E87CD
+ 2D5DA9126CE1E3551D3896BA53E6F0B6F5F8A48AF36099B257E9E1868933E01E
+ 426C78DF71DC73A88D63CCD20829C3B4C4241DC07B5E048FE05875F315D15600
+ 1DE1169EAB2C21147A71C061476FC8D3EEF1344DF73EFC1C23CA11C7A6C336BA
+ F988B37E55C20F4138A7B5D8FBDBFC70BE5D37AF6F7E6958E062C6344C142499
+ 58E8566571B9C79ECC
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMMI6
+ %!PS-AdobeFont-1.1: CMMI6 1.100
+ %%CreationDate: 1996 Jul 23 07:53:52
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.100) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMMI6) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.04 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMMI6 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 59 /comma put
+ dup 76 /L put
+ dup 80 /P put
+ dup 83 /S put
+ dup 105 /i put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ readonly def
+ /FontBBox{11 -250 1241 750}readonly def
+ /UniqueID 5087381 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D6A8F05B47AF95EF28A9C561DBDC98C47CF5
+ 5250011D19E9366EB6FD153D3A100CAA6212E3D5D93990737F8D326D347B7EDC
+ 4391C9DF440285B8FC159D0E98D4258FC57892DDF0342CA1080743A076089583
+ 6AD6FB2DC4C13F077F17789476E48402796E685107AF60A63FB0DE0266D55CF1
+ 8D0AD65B9342CB686E564758C96164FFA711B11C1CE8C726F3C7BB1044BBD283
+ 9AA4675747DF61E130A55E297CA5F0182A3F12F9085AF2F503481071724077A9
+ 387E27879A9649AD5F186F33500FAC8F7FA26634BDCE1221EC0ED0E359E5EA5E
+ 6166526FEB90C30D30099FBDC1BC2F9B62EFEEC48345160804AA98F8D0AA54B7
+ A480E715426651865C8E444EDB798C7E11040AF6E5A7ED1888653C6DBF5E6169
+ 70BCD9C063B63B561EF165BF3AF11F8E519F37C6FDA2827685739DE2C48B5ADE
+ EE84F067D704D4511DBFA49E166D543CFD9ECD7417055D8A827F51E087CD2927
+ BAFC7E6CFBD70B0FE969F890A11149D3D44D422C3370495DA9951AEE7253A49F
+ 3A9444C8CD9158D84117299F7F2332FEB0F94E6ED8BC7AA789A3219BC2F227D3
+ 3B5BC75FB53B55D72AF4A6A7BB613FA235B11BB37D059FD87127CEF73D5B3FBF
+ 9F91ABAD78BD9240BD9525EBA78095EA0BDB25D1A19E876F292882EAD5619D46
+ D20317A345D931F4FF4EAE6216C27044CBA525E3B917CEA25A04C120466C4B93
+ FC720E6BA832A06CCA0A3916CEF0968D49085AEBD243C41A448289A6F05CE3F5
+ 79148DC112A3CC7E8FF810B8C1A09E05F496C0F1EBA334E42E05C376C98F5F69
+ C06C71BFC0A2F3AC9951CFBB143C66FB84F9C4ED27DF70869352D61BD5E11508
+ 0797B87C726B4D833E4D8BEE1C6CAC488B0D6776B302024285AEF496E42CCA9C
+ 5E98BD5AC4C3B765C697C5E901A8722112D131CA087A5E2D3068309998E6E066
+ 90B844F2047DF6F53A9DD092D4B85711DA4AD2A42513D48007DEFCC518EA7C15
+ E98208A5FAE3F5D92554E2CD6501DC4F3F8B8BC9CE6E1B97659EB5CB0250E8C2
+ 9FB1890616FC16AD827C523AA4656E786354D7C02F3CA58BBA9036B48998A80C
+ 5AE2DDE7D4133EF6A69E5BA93E502BEC528DAD4A76841CFA6B2AFF80F90BE34D
+ DFE123D169251818C7E07C15E36B55F260B7AAD4636F0D3690004AC1CA9653B1
+ 905EFB87CC5E5CA21E931D41CFA75BBDA285630745FC00C954E656BC578785A5
+ FFB232DC8F66E7009E42DBD82E1100D039D248DCBC2AE83F5FEA0A6AFB0D6D4C
+ 39E1AD4F71650575F67A2F08C4B44B105FD17E3EB08E24F9261DADD36BA92229
+ 40DBC018BBC04836AFB285389DD03DE8C42295C7CD72299BA1ED796586465975
+ 9736206E7C146F61C993F074413B61118BE7712BF28CD795288A59195CFBDD02
+ 14FDA7F89FBEEA848DC254434F234922F251A6BC6A97933879FB95CBD2210C90
+ 6AC5A0D5363BE9B7E2DB3366F2C9A2C33C79E473ED085F0E03E4C88E3032A098
+ 7FB16ED95FD43373FFCDAA10FBBEC178CF634CA8E0475BEFE465A7DE01A93DE3
+ CDD4622A7DD0A12E403BCBC3E8FFB3E49A61D8B6E252387E5D33759B2AE910C9
+ 01640BE990A5782B16BFBABB22ACBCD3752BF71927B5082592291D2D1B02802E
+ 8F69F6C3DC8A714DBB1B8226A4140E087B17EBE94BA11579C1E192BB2B68C545
+ DF1F157BBCA7E9D717E7E09872A93192619B5FBF88690059357D12BA2493AB83
+ 3497F4E8A5A0C2B37BC2531C35EA32A15091DF97B9E5311254A5BC1086350BA2
+ C7D9B882A9DB1C06EA255B01EB2BB398C5B906C66CE89D1218FDD4EC239946AE
+ 7CBA72407142C35D0FFC7A149ED0735F8861DA8D0B3A678A16658334D4A16149
+ 62371095DAD1E207CCA09FB59C14691005D9E474596ABCEFBC439E2C0DED673F
+ 4F459E6629EC91CADC6BE003D2BF550AD3C3FF12E598D1E108E9FD18FAD6DA05
+ 44069C160B7227A7075C86A8AB20570EBF5944BC38A4AB379BAA61D7C801718F
+ 1CAE750F5EB0934091486B8618CF01F376477730760F6DB03DA9263BC3A0AEE4
+ 6C5D0B891C735D9452C37E9D1568A440702F561FF6963A12A10A4EB7840F4315
+ D791FD6B1F6EF44ED77BA5C545C73B080D25D3470C9445A4501A3206ADF49617
+ 8A8017F1BC0767262C185422C9DB742B4E0AD811F1E1972F74083B17D40124F4
+ 9183FD3A595D03E12BC253383EC4D61EC6922ABB9F85E098499C940C73E5B662
+ 6F4519501EEB986CDDD715969282619F52766D80A43503E42B481A8C768D13F0
+ FB0347F209422657BF06CB38FF48458042B9D4542E0AEBAF6225697DCC42DEC2
+ B6C0DFA377E326E17F70890EE5B38DB6EC58AEAEAAE51635F76BC5723B8BA5E5
+ D013ED5BD9B638462B8D2E2D1DD143FD4199DA96E5C6899565442599D3634D72
+ C435E15F59AB3FFDC67D078354EAC3776875C49F0C80D6907FEA1B5BBFFC9775
+ 693DB19B171F06939A2A306B7793E2D9D3D760916CA333F45188206D0D12558B
+ FDBC0142142383E96BDC5DBBF18A8BAF800296BB228E76B41079327E8ADAD67E
+ 49C49C4EB8BCB7F8B0AF7E23DE18CC89EF0C54151D8A09CA4B73BEDD4E85AD6B
+ CD85AC64C66998CC653C82D866F0ABB7BB5C0C03137CAD7A2A24445D1BF697CA
+ 97421F2ED626F1C1FC62867BB9AD75E4397021D536F7B53C63B2838904116BB9
+ 7FFB4A40D4A5907232DC407614BB02F6415E673E37DEF57134D330509B8BAB32
+ 00C25114BE5BECC09A0A0CAB3BE868A3ABFEC761290DF46F53268623381CD20E
+ 8A3DAC1F9C708B6CE9E2E341844B8FC90B1B7B7606889E9938C2DDCD77993E69
+ 7DDAF8378DB916178CA1B9694B86793CCA794B20273F656D325BBC7D72E85155
+ 9531E3ADD6E37B9561D6DE16D749A4722216596F568EFEEB592E608BF4615082
+ 21CB0E069C2DAFD1A7099FC35D84879975516781292B024A61F8701B0F9DB4CF
+ C74AC3CC7413A42B24612BA0FFCF5BB90EF429A014D1D0AC399D9B55C29DA11B
+ 28969EE5E75FC48542A1C0E45EAD43261FF35A37F4D180453A65D267514C9F6D
+ 2FA387DDE4CEC55188052A6671B68958B9058C7776AD2DFA5D111881B15266DB
+ 602A67F917B22295630923CD5226A0809E387F6F0FAEB44B0C0405671C54D22D
+ 53A2F5DED2894D94D11E791E8D778F70E080E8B837D204FD6095614AD818CFA1
+ 37F24F4343EB84ECAE080C7AED828D6B934ADEF4BA1917CEF2B164196DF719A5
+ 88E9460AAD5EFBEA0FB36E5B264BE3CEB09EB085C1BB361EBE92644E6662A2AE
+ CE1E3DD893D665A4E6F73ECC696BDF227CA9C1C1BE0AF19A6A129D53151BFA18
+ 4EC62E6A2B5B292177C60DF4B6CDD99DB0B5296640F24A525191560684F35D45
+ 0E1028FBD46AA11CEE2560FACBC1779D0FD098EFC43DCF97A348D5480628191B
+ 6A7AD9BAAFE3CAA56BA3CFF5684D0E0B2306918FACADA797E50254F0397C23EB
+ EB92D6525D1EFD5A0076DDD24F47F4C2B7858F3E213382562FC90C340CCC94
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMBX9
+ %!PS-AdobeFont-1.1: CMBX9 1.0
+ %%CreationDate: 1991 Aug 20 16:36:25
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMBX9) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Bold) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMBX9 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 12 /fi put
+ dup 13 /fl put
+ dup 34 /quotedblright put
+ dup 37 /percent put
+ dup 42 /asterisk put
+ dup 44 /comma put
+ dup 46 /period put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 61 /equal put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 71 /G put
+ dup 73 /I put
+ dup 79 /O put
+ dup 91 /bracketleft put
+ dup 93 /bracketright put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 120 /x put
+ dup 121 /y put
+ readonly def
+ /FontBBox{-58 -250 1195 750}readonly def
+ /UniqueID 5000767 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F0364CD5660F74BEE96790DE35AFA90CCF712
+ B1805DA88AE375A04D99598EADFC625BDC1F9C315B6CF28C9BD427F32C745C99
+ AEBE70DAAED49EA45AF94F081934AA47894A370D635D93B1823EC35EB8316AA1
+ 86031FCC99F57CB21E8400E54AA474B57112F0D4754A16BEC19117E9D3638986
+ 0777A71B135CC18E20E193AE6C2BCD89F4A27516DBD2BFE69FF9920D547796F9
+ 89E0825B6BD5F492B36AF136EA91B826501ADB1979A4204B2CB5C0517F2B9494
+ 9B2077F316D2B3DA256C99F7549E6BC4B04FE12072B09B4F5D482A126AE351F3
+ 97DB85F3026A793B51E6B28B54661FEB087F011F0BFF67272DD1E8825C180723
+ 22AE77CD6166D2605D0C0F131537417CB60086F08E7197AA916D590944BD801B
+ DEE8F29FFC516E11396CCB8395CFEC9262E22521882DC0316B0A129DBFA5FB57
+ E656890C2471675E0566FE461028FB05532E274E6DF77E7D320D09B2203BBB5A
+ 8B185B66B2F8A18A49589C4EE27596DD56260D0D759D2A12CEF7FC3010BA1B36
+ 85A2FD45129DC01A0C7570423305C25D957DFF9215102FFF35F428C823D549E5
+ 014E7F99ACA6C10B3C92805376D0F3F280D65852CEA54F5CC9DEF9EC1347824B
+ 0733D3341B34937316E77E952AD9366D3B2ED045165565F07CB636385E5A5911
+ 2620E185B105EF6C93890833054E05B6301137338A3F1D6AB2F80095E57AE60D
+ 6E5EE2764624849978C811EC38E014AE4A5823734C5CEB2BC22DDA46BB408D00
+ 4F25CA8ED287D35E26A4CACA77D2D4B986ED2ADD3BC0C3405741CAD56DE28C7C
+ 68E8944967C022CC55907B3DFACC1EFAFD38D3EDDA1AADB6E2C006ECBEFAC8D7
+ 18ED3C46C331623D8FAACC6CF9292B8F1B407806A0D4808F51A5BC97FBBED8C4
+ D2E07198CE888288CDC793B818FC2C9018AD5AEF3897C357ABF25E6A317C3CCB
+ C5D599C47C766912D3969B79B2325148EFB53CDC6CEA72DBB3479C3F110714DE
+ DB1770B782B7EEB09842688C5E734009212576E440350BF652976D11E95B6EDB
+ F357CF606B60FD70DAF6D1A59E1C1D404E35B1F9FCD4123D7EA730161F8E7A9B
+ 15AF2BCA0C1F7338E3CB7BD55D57D1B25A31988F3EEEDA71E7915BA7829EBDAB
+ 2BC3FECEAE42B282F4EB1BAD87C3189218AA6782654399ECEE06FFA05ADDE70E
+ 978C7EA475C17E5350B0A7766DBA03B27960AED364B33FD80A00E7304E7BA6DF
+ CDA7F0B8D46B5959A608E155168DB8AFB3924424CD98CCA89401C7A20603FCFD
+ FC74B36AAC9F26C711CCC926EAE56529E54B841BA75E749684CA40351734EAEE
+ 7695848E0EAFF8C4902508F0793D091E881C610777994AE22189961E6FD19AA1
+ 5E4733B6DB5B590DDF0DB5AF237C84C41135AB02C4F531E96A04FD0F17BC8296
+ 3F6F212179DEF611CDFCBA37F0A5E883BF23F733BA7C451F07517768FBB69581
+ 6D04028D72155B6291BF4B1075BA7D4169AAA58EB64E35519DB3F57995C4B76A
+ E26BA3C4D952AA4EA92338AA3F7B9AB5A523C226CE4EE65AA4BD17AC9EECE468
+ 17CE19B2A7AB463C911EC1A9A083C7FA768AF652A8FBAAB88238317B17E6386C
+ 699312790F63D4E28A68AAD6BEC5FA4D335481E769B7837B3DA8B09A0A23D6AC
+ F13BE0821C7128E0B51A399CE87F4CFA7EA572085371AA7E82A6125D1AC6B06A
+ 61FA35D58E3E14DD9BAA21E3B4BCC95EB82496CF46B682EE29AB16EDF941E9D9
+ 3957087E3A9C30FF7F5FA0BC9DBB1F6F2DE0B8D704B064DAD20F7BE31B31C59B
+ 0C270C234C1145FE757F260BFF2E53718C7B9008A8BF193B6AC4CD1B04491112
+ C1D4615CC755D1638052085AA01DDAC44364A4C6B7AA8D683924485657A44D41
+ 1274EF7C6A5394F7CDE09778A22A71EF2D134C4700527B0E765AE9D89B1E6BD0
+ C4037B353BCCEFBBEDDB6CBCBCE398B229476BC974A648F265953A8B5DB7EF7A
+ 987E160E62390F9FD47835FD879A461985BBA9C3B3B88B474A41D2576A5348EA
+ 92E373E5D5A93829542942FCCED2258617C1ED434271F71C1CE81190BD9987A2
+ E050416A033BEBBF05F99AD208ED5F0116EAB914466754EB571017FA9BAF8B78
+ EC344BF7DFF91F9E887F15C17D2D481625BC909782B340423A785D1EE60E790C
+ EDC3F6EC3B02BDF5760794DE494D8AE8B25D1DCF2B60766BD3FB405783546DA8
+ ECFF12D4C0174CDB84911486BF95EE9790946F18CC1FB3990CCFF38982434BEC
+ 77953606F8C2E8F11273B8CC41468748DDD8DD778BF9113C8138806808F72842
+ 644A11D615FB03ABD9C62C90AA14635198902A617D1D369CA1F2F027DC58422A
+ AF4F2D0396AAB8A091AE0D7DD4D5A41FEFA364A164B64293F6587496DCBFD423
+ 5F1737F91AD3B02AD81E186F3B08DBC703B462B172594ABD2850D8671A9A0C4B
+ DC24255350B6B6FC4C53F899ABF769CBE6E62975EA36EDF5051122BB3CD04E63
+ EEDF801E65CF46EA184F1FC48AD3D127EF8F7E3757FC02B28AD9D8C32E6CBC68
+ 92A6AD90D11A39C85D15E864077377916A525B4CB7572F19B2FC9534C3F4EAE3
+ 4A60B241C65D36849156B3C15BFBB24AF9DAD791E2A9ED91E5A0C8085AB249DE
+ F747250EFB00C1EE4E650FFC2489602B8810B670A2A494D0155B7A8E9196F0C1
+ 772BD2A37C81ED14B0E2E20B21891339318D46ED5C5A5241D5BA2ADCF8FDB30F
+ D3F6478B58B39A05ABFA4B6515D7F59719EA1B8D56BF94BF20030631D8EAC20B
+ DACAA8E415DC2278FDDDBAED479DE603332B353E8CB6DA78F942E41BC21D7352
+ CD78E5CA8647010E0DFA67E91C3CFBE234E868D62B3CA02832A671394A966057
+ AA99F4C1B0469CADD421A82B9DD48C3C52FD09D02CE58C37A6DBDCC04A9DAA50
+ B56B17ABE44E563DE2E1437E7263CD4EF85B8DE28615C01A529A8CBDDFE70064
+ 1E906ACF70EDB4B6E55ECE2EFF83249905EDB22BD39E8FB046CB9CD7BC7CF53A
+ C874EECA871FE73F82A4C85F584C7CB35D900E3174BCD8845F72725D21EABE24
+ 3C826678A3515F3B3C3E96DF829A455067A5436094584AB79F25E1F9ECEDB646
+ 4B21E6B3F2F97A83888015E48A92AD473197341C74BF160DB60E928CCB0072F0
+ 8BBBC6DBA0B08706DD8ADA7CD434CB81647B83DAB2FC78B58A7EC613357A56B5
+ E70D1FF3B653384662126D6EF3BC02E142021A376574FA0C0D7DE2AC24C4B5C7
+ 8515B7C704E536D6A8C02C993CC0D59D1A1DA55AAD563DED3A543FC43DB4D00B
+ C6345FF2F533B55E4478239F35CEA407D6424FC9D2F5060797479E29EFD917EB
+ CD2B6BEA3D304DF6FCC23366DF3D8FEEE51C0CAE74CC60E8E884FC42147B1372
+ 2FB7FA48FFE5EFA60A0E8C6AD0566B0AB30F62D362C4318985BED66743B1A9FA
+ 4C1599FC3C1FAF616756D9AC6B820804046BD1221E2264778C727E6D7142F349
+ 6D13C71196583749D6EA93BD48F956D06C3079D693E5A0FBC43E27D07631DAE5
+ 20D5DDBCBABC022F4E54AE28491FC9C410201D813A0EF6B31D12363EC995D3A8
+ CC66ABEF72EEC38188F6C21C474966DA6D23B0DC8D936387E646066E5E08A6E3
+ 40B20F18150CD4DD7D33E361C9175E55C376430EF7220F0CDB2707FDBE5BAF27
+ 58271A082FF7B84A62A74E311A3E61BE39C3C662356F859A66E7A1FC9BEABE58
+ 55A592354E5E2CD270301B56FE13ECC707C8BA8EA1F2CA2369DEA96A9F953CDA
+ A1FF5C1935D06BA34A43170FF3AE76BE4BF207B1DB4DE42FA5E9EF1BC4C96467
+ 9E544490BCD0A87CECB40BCF372735E0D57174C5CC1BDB9930ACB063C9CB3D48
+ 1308F6E503DC95AF187D4CA3D08C254B8F56F21F8519807828B376B931CE89B2
+ 56DF3B3C7619C08E810060C54DE1083119BC38BE12BD58C477A90E9F9C35C283
+ 907A124E575733C7579CB0C7BE0570048BC5211F72169DFD9D9A085F9646CF30
+ A504197A04E70B705443D19031A3707979323CF348E1D6C63CCEA4B3D2AF7037
+ 739C3F9EA9B6EABB87D8AF2581C882323FF5B1BF7F26CCF3A0A8372F100CE4D0
+ 9599A9E393F64C9CEBB4BA88C9C25B08BD5D0F8B57367DDB4978359EBCE195D1
+ 8E236B0FA38623B12F73524B90062F060B3A1B9D29821707FC52DED233D03AB9
+ 4C3600A1E85948DA1E8B358EF83D54B4C5B96643857A8FDE33BA9182C8D64A3A
+ 2B30237CE5CD7CC271F7AE3960E8A965D832E7CAEC45CFC2A000FC8D0194D783
+ 189C438152C9F4CEFC112B5E5E7DC743E8220DCB191F54820617A953727F2EFD
+ BB7F629CD5A6AA3B3EA0578A98D73208FD2CA634C265A5B7959C9C1316CE2357
+ 479FBF5723145E7381E73756283103771E03722653FE2D753A63C320633C24ED
+ 62EB2312E1D0CD48CEB50683ECF8423CDCAB661B9D37E3B4FD5FF0BFDA312768
+ C3B98FCE71D06B1800A1268BABBCC079081841DFB1B4C033539FD6DF52EA7382
+ 6A7CDC9BF9B628E151821AD38D9F19A229BB02BCB59AC35E3E6C01B659E3229F
+ 9A658CC30F3F51EA81F1E3EF18272A07474FE51D8307AE28D45698B7B100D3D5
+ 5A56D9285F743EF1C3740589D06A4E64973B8FDE3649EE4D30308206BAF47B2C
+ 3F4E4EDD5CCCC3F84E85C8076F8DC09CF4900674AFF52490D23F5B7B2B8A3927
+ AC865D5D4A2B01AFC35E934FDFDE54D1651F05289DFFC1944D0CA61DADC71A0D
+ F5E4D516D9B006E08E9CDC3B8C754BC65B297D82D4C340CC50F58197C8B00070
+ D3DC06DF9B9F5AB80B9B5F036946FD447E0C4D619EDA53771BE54B6A75B2C32D
+ D7B6B7C1E56236E730EBF9F0B0E414360771568DF90BBB4504FCB7DE06578C87
+ 2B33519CB48D9C3B29EF6C38E0CE8ECEADAC7BDF54D113EC05B92FC8007F7F9E
+ 6B8633C73A1A603578DD9B779602C87F9A269FAE44D6F0B442225F9BE33FA96C
+ 36F9C67A7ED5A98212317A580BA299FC52337034768C66B57499C97F691C3C99
+ F8C5E0C15CFD8F2DD2992538CDDD172BEE813C6E72ADD2126673331B25EE8BE1
+ A10A6D4C10E0FA7304829A46758228BE82BC332FA53C63A30CC063F4957627D9
+ 29195135FD9C340384DB26869ADEBAC012A1A2D57D63A66224299839B40D01C5
+ AD2B361522BF7B7423791A2363C24C0DBD72A99CCDDEFC14FBB5C2394E0387CF
+ 1A811EA36B5509B6F53F68569078F6F10E7B3B4A72C3DA5F4AA5054EB56815AF
+ 1B7F2F3CD21010E8D2632E705583721D39CC0A30EA07F86F4AE34AF3EF8CCFAE
+ C4743BBAF7BCB498DF8BF5E1970AEEF42EC7B620064FBD239626D012DAD09F5C
+ 27B9FD0F8851ED45F6DDCA1E9105FBE4934E4A3C20496FD0B7B302E4F4620315
+ 9B137A958237E43A6E5F5F67CA3436030FC60B61E4E8458928F883F85F40AC24
+ 472F0C1700DBAF728C262E555EA11E1BF7A8171CA6A34C14BCB07F59F7CEED6F
+ 63F6643932B2323478A4962D0FB55D72A9211D9138660B7CE4B6B8739A448C1A
+ F1A591554C6CC7706AE05BE4B469AECF40A616E5D955668902E71B69432AE2FE
+ 78ABE1EA4322E284DDAFA8A658EC8C4E75C516C09CDA3C1330853C7122CA9CA7
+ 27B7D49CB4CE6E12B05A8303D21637335C17845BB58DDFF081B9881196D829F8
+ 2D972BED97CC76E5C340F740FDB43EA4EAC9F712496E7BF9E8CE9054541EE5E1
+ 4901EBC085BC4E6E6B0926CB1901851AFC644FE631EC5071C6988A961A2DBDC9
+ 7111E40AABD04D5E6E41F636F292109AEA9FCB1D033FC012DF6623FBAE8FF891
+ 569834A26BEDD3BF6DB28C7E29CA3ADE2B76C56708EA5F186C594DAE9F689E91
+ 2D8D2A7B9B40580E849ACC9477FCF2737A915081EA03792ADAD6EC339B1C3AE8
+ E88F76493CFE914954F4226EEC79D2928A81551C6D389044CB52F20C9DE6ECF1
+ A37094C83E1AECBE383DF6B0E840D3075AA699FE610E01F6DCFDFE12EC9EF055
+ 9E48C80E228C69259B3309E257022D8A0C3ABE3BE7333C0B782DB7A28887EAC5
+ C94CA7FB387F2985C05F28EF50A595949C052C1E9D1C30D0818E546D0907A51F
+ A64975783804989D54A92A79CC83FA06963FB2267489493D0CCFE16BA8988219
+ 1A3BE49977B8E592E9E1D90F540FA9EEA6EDF64E90548BE98871C5BE9BBF89D8
+ 4D67079FD8DB2CFA68C896F5807E6C8F6D7F302B2524B496320565C679D14FB7
+ 5B4D045DF8B1A024989A08FF72713C0AB89BADD218C451EA4DA3FC89CF51B705
+ 959C7F58D9BFE179D6CDFE57B393151F7E7EA76F03090600A4A8A22004C1BBF6
+ C6386D99CDC7F090B2454F16BD90BA0217F83D852C49C0949B7D65BEA943B958
+ 9464A6CEE110EA4A6133249BDBAD6C9912A2E63FA681B9D951A6F1E2CF6515E7
+ CBE9016B3C4BA3DB81BBBDC12745A5976862055AE32C799CCBEFD20A4D14BBAF
+ 37B57AF78D19828746597648CCE174C223F4CD67F21BD8E08EEA1CA537CFAB6B
+ 85DD24FBE799225F8651A91316170FC1A78002EF75C097727285F3CAB6B03569
+ FF1C9878101860F8A4E275A3EADB8E370979C35EC51FD50AC1E10D10661440C5
+ 0B4982BD7224706AE01638603DD17028F387CC402F2D2130FCB04E24390FDFFC
+ A8E1A58CFC70F1CEC9AAD4760E1C1E390C3B12E01DB10369D66750891C94CBA6
+ BB7166E0E64D906181212D8D3090F3D22FFD3BE630A0B6DF2D20E941A63A0BC8
+ E43C5329D7BEC04F217082EEA8A2CC9185F9C3E0C048E3E7EA4CCC536AF1C514
+ 05F6DE899AC4B9ECEFED6A3D1C970021337E39E82E59D64EE1BBCDD5FFAE52AB
+ FCC154F1A68BA86712FAB90FB253154B7A9E8B9F72F8308996847601FEAB10F1
+ 140D7F8B65B85EB35934F92F092170956347E3451087256CE620CD9551BEDB4C
+ 187F6CB7DCCEAEE6721284ABAE633AFFA5B8ACF2F1910BB06D9CA055847E8B40
+ EB1DF21E12EB2424752ACB31E62FF2877E3D4C76B7B9FF7DA64EA62A1F683D68
+ F55AC391CC414DA6E7FB1CF242B6542CFF0F8418B3CDF5F8D8CBBC08FB97C0A9
+ 28B4EBD8C41D0797F4011ADA78EFC1DE9CAB69B4E6D53EB6005CF246FE905127
+ 4AC993A9AF7A451AA28A355D2474C022ACFF328D894A71C5352ED5CA5E9FA918
+ DCB8F0940164CFD0F6309AB32CF8A815346EAA469495843B9A5F594ADEDBB7CC
+ 962D0989B7F829E6C0A8FF276A2DAA1C50A8FB0567150148C8DB200A775B2AF8
+ ACC8E6F3B44C365585CE395D910F54FED61B834693BD8E4863750A5D14F18C78
+ D9B21231439DACB257CCAB1045D8C4897425C5AFC37CE22B61495EF0EB1211A1
+ 8B9FB97E6C2DA5B56054C2F43D5FC2D96804C98E4036346C493781D2500F7936
+ CD2EB784261A3DA9C001D5C3B1B4601BEE26410044E050CB1977CABC49F049D8
+ 8B3F800B886491F85A9F05C200C35323792B5D37FDF5F84372B929F7A613CD9F
+ AA4ED52B4109A06AF4766095516BF7730A9077B92FFCF54EFBB637B4DD0DF2B8
+ 8EADC875B3B3B9AB3D20C0DCACD3075E4A0D9B2A4197A5FAB3BA912B15795B04
+ 7F4C4D468BBD26A4A83656E50EBFC4B40A87B39C54F9B1C78A9786B27A4002CE
+ F17D646733F4F54AC9AAC2F52BC2DAC233B52F274207D3C8C088B7708B3907E9
+ 4B4B4EF1CE4692E2B45024869F4D9DC2BA947834C01DC1A9D14E7620B5E7522E
+ 52A6E771D6084A29DBB8F4417B8475760909E5B022FE9F06BFC97B0C3898CBE7
+ 9ED9A59497353D0CC2BD2A979F51E8D054536C3BA6D3073938CF4E49B5D74E74
+ 5F117EEFBDB67976E25BA830EB875C689F599CDDE4F69CE6560EF131C1050A64
+ 44191DFA951934DC8540E34D29C397692481C2AF1465DAAE73B1CFB7DB500AF6
+ C498AA636D4200E482E05CD03CAB5A56C7388010F6A7F09E17E93AAFD5306080
+ ED42AD353ED5AD25EAA563FB9E8630E2BFE2E1F2069812538B3CFD1136BAB92C
+ BF2EF8FBE78109EA054DE0F798940CF5303031CA6319FFD8A99891938E64D5EF
+ B45C87AC2139592372B0CEF2F1D4DC958D275A09D851B691142B78D535E86A07
+ 02C99590D94591F70EC1BC5B11754EAE586E64644738593DEEAF1909FAF06C95
+ DDAF6074A08C7499C3A383243E27EFA4A5BE7B6259E5CA656FEDE84F51446041
+ 8A3D9EFCA2DD71161347B120AFBCBBAF46169C411A621C5A66419BCF106FFAAD
+ FBF1B26CEE213A3EAE95C94F83A92A984AB09951997E8139692CCD1848E35B8D
+ E22835F256EAF26F8411CE69CF64DD88F817195635F30CA745BA1970A3B45749
+ A6A93198888EE76A40D499E3BFCE3D26D917E9BCB989D37FBA88729DF1147372
+ 55363E022A6E025F730BBDB562441F8EBA8CE52AB427D839ABAE6970CAA34A2A
+ 6ED471EF22F576A288E02EFDEA1F2441CF9F2137B51CD104F7ABD8B9F8697B15
+ A0B2D4383D8153593DCF63DB80AD562FEC21EFABA75E5773F1C5D37433A5A03E
+ 21E454B60B175E8021DA8895D0E66AF5EAB25D8B7338D5C5860E55CDE69EFCA0
+ F85B2F6C290852C13DEC54D665289654DF5686858D6B40377E1FEE2C11E20C87
+ E121E599DEE4DADB0B4472E73507597D36412F05E7D5517896801F279B74EBD7
+ F8FB5BD858C708AE654392C08FBDE3ADF4D8F71E055B530933B17BD181010938
+ 925DCA6EF936702C79F134AD1D45882288DF74ABA6852BFED940E72B6FB7CAA0
+ F3907502F17E0462DD57B3C7281246BF356A7262F97C7A96A54C74701A8A3456
+ 631FA578B2036D22941E47DAF3A73068E3F31E51CE3097B37D24DDF8B60CD121
+ 221F04BD917A98395CBDDC5B2BF7AB570AA04B0C6EEE1D6862EA84DE1568AA17
+ 8192F4CD5EDEA900899659DA2BC1F3C30DEFB42720BC26C482FA6C19898491B6
+ C947801B4BAA18BCBB1F52410063B17725D1B7C307E0E46D262B84BA07D1B921
+ 295A394ADF907DF6AF141DA9E437C67ED892F1CA85E2FDD62106CC23313E7F11
+ 4B05DB9CE1D962B89D90650EC6EDCC4C7C05352E3500D2CE94850A13FBD79643
+ 7D8BF4ED18B73FA655B4B78A71DE2CC6A534FA6BC9CCA92628CCF84CB617BA38
+ 8031CA1BA5FEF6932112894A76042D6F2E4E0AD8C621AFDE3538232D49E6204E
+ B47AA597BFCA49725D0C999D80B6F31D3BD2AEAEF366EA562E194E22D1D5F65C
+ 1FC51580EA7E04125913D17C09F07802C956C8F4411F84CD68BE54B300E5CD7D
+ 9801B022C24CD0595321DB18C33ED7584C741D747DD1C4842F2711E7D8CF5759
+ 67244E846223EF0966DD00D00B73B41FC84730BF44789631F8571496E36649AF
+ EC4DE886486F35A69E6877747362AEB9A4E877F978DFB5E418B0ECDCB0D435E5
+ 0940EDD154B55B9C051C116F0B79872A4864A9F8D7C139AE470C5AB0C74512CE
+ BC51E55EA227AA475328BE4BB07C26F41F9FD4269B08FE9F6A09FD3090BE5826
+ E9308EB11A426875EEC64F6C7D22BE8DD125DC6F0217F93F144A42CDDC63E978
+ 59512F60D9081601D78E4717862726930D8558001FACD9A5175E1227EF76C6BB
+ FDD0ED37A522C33ECBD6C745DE515DEB45A3D90FC178A9BBC2AEFFCF31B8C01B
+ 601A9D04EA9C70224BC0FEF92BAD989EC8E760A5020550A99829233C5835C348
+ C9362A073F678B66BDC98A460A961597121CE354E8466FE032919C5A0C42F444
+ 7192D11C3428501BA357323C45B12880DE339A1B5B70797326BA229EB3E27CCB
+ AAE24D746FD22EA88CD85A7677A4A928EF698D33581950E44B0AEBA8C02CE088
+ BF637D51A292C876A850305EC001294D2EB94295014D258A1EDCF385BF7207F5
+ 4B1C56A5EA971F5BA00CA8B4904021D276DCB62E5C267C60B9B9BFDCB542CBF6
+ F2386FA1BFDF246A5BAF70E6F419D813726BD17580BF7A30E978E8F21A1B0115
+ 3E484201B8524571B82BD91CF86E05D2A37B00DCA074DF43D47727F26F44AC60
+ 83AE0D2F83085D1089749D0E6ED2B0D2EE359A4E4019FD1FA81FF642B2063AEC
+ 9EE2A1EF8FA74F48D1B02D21F876D7D3600ACF80A475484776A98C0E4CAFB799
+ 15A6123E7165236C46BAF90E2FF95A2E8A4094C40CF99E062145F0D0A675A2E7
+ 8520D65EA3E265A98BB056F6B6C28CE85365F9221D7D04D388B84CFA63CDF96D
+ B42994DBB5A08B4014F1B075E938D4441B4851237D1000907446E3E6DBAC43D4
+ E79381500C5E7D5ED8FC39FDF397B957F77123DF26A474D22785DCB6C7722DD0
+ C40FAED19424578F44219B4DEAE54DD17A19530138EEC97561B95D20D1F4A056
+ 154D14101B6542069E26FC9D4E0DA122BD0770FB6345495D524C3B258400BA03
+ 2940812558BA0D6CC6483873B989249DB2F6BF53CEDC45C8F2311B7E09502DED
+ DB597016AFA6D5ADE804FC6C30A870AC9625C21DA6310FD7DF078E0255565FF7
+ 061B2033DEA351DDBE34A8DFCFB0580F4EA6192414946AA1AE87A477479161BE
+ EB20B1DC246A1B064CE9D0C96C6C56F007DEFE60F0115A23ACB7E42257F45C5F
+ EE80C957C875CCCA78F311E3020302B859291C2BA50E4E8E10160ADCE591C051
+ B1CB1E035C7140CBD4C67C766D685A8F3179D1440856CBF2A71B1F6B54CAF7C2
+ 5523907194E634B8048367D64BD63E250ACC4D6F8180DD348027D3DFA173E6C9
+ 44038FBBAB198889C9A21AD4A69440185D756D1F1EDC1498137CE4F25B4AD162
+ 190CFD24A463B55F7979C6B4869D49A6B132EBBB8378CAF42EDADBACA3D4CC01
+ A8450079FCDDD0E062211F18186A8C211A4C87104A7E5F0B435F5008FE0F176A
+ 867DCE6CEE1AC9F5952D39AE956CA349684489E0B51C90A5D7A7F7493E34E0CC
+ 63BD56770CF8D4D6F27D05C52CD4040E11F041BC56FDFF6C997F0AFC4D0DD3EF
+ 75EE33243F002329F0B3F79FF1B367697DD950D43FF085BB1EF4B727BF2D7225
+ 0238DB236337C4341BF89AD8A66A52762D1536B6ADAC2378C7006A96AB355CFF
+ 29F8423062FC0A7572FE3F6C8938B197E8C7A45DBD146EB4EF9ED26AFF4E041D
+ 7BA301D8240D3109DCAE986CD982F1CA70A654CA24E3437C816A571C37457E69
+ 6670C0455DFCBF8D505F38E1D47F154F77BF57325BC0B14757DFAD091A8FB37C
+ BE0274919940DC4FCCAEF1AB763CA435EE797DF893C3AC6FE5F062A0022A9CC2
+ AF91B33DB94F7009C0F25B1B63F5DF20227C9B537CC694FE5118778C9C4677B1
+ DC12AD31CF4286CFA54C4AC647402D3C13E44EEE04878AC4045BAF862EAAA92A
+ 6160ECC63461EBD43D5E7C809BB12987A510476BED333796B9C3C28A09331F4F
+ 37862DE240FB6A44786212B21D9AE98AFE8944537B500F18170C2B5195528864
+ 77D287C14F32F394E0242AD5BAB55D7E2AD33B71B86F6DF648823D221BF9EB0C
+ 5933DF223E4057A0E2D0F90D6ABF646D1CEF278D37102BE786181E179BE18BFC
+ 1B5C894848AA6051726A4FC4042931F6C7445C684D87FB21FE317A1CE107BB50
+ F27E1DB046AE2696451C28E0CABAF08AF93BA5DA20F3BABA7B6CD4E59FD9A380
+ 1D0E116E5E23AFD27E2F9016CC77C359B319371B84C51AE78B765EFD392EC726
+ 3901729F838CD2126B266FD1CF234344926797C0CF575C689C2622EAD7A72E0E
+ 5F2817CEFE2D1DB439C3F643B0A6C1ADD4A8D04FC290F208EA0A6AE5FF3121CE
+ 50575392D7D582B5742731D2D8F246DD282C6DAE14BFE20E036679DEFFAD45FC
+ DCBBDCF80F4CB1A688CD9FD958892AFB8757262AB36A3DD8B43273E0DF6DDEE8
+ 4EF7E97FE0E21F12A9F131CE44A9D4E3605961A024A50E058F32D07D58687D4C
+ DC7EDFA36F81D3C2CCF22C21D6616DD610DFCC54BC107984F07E624B5BC1F05D
+ 241C3D349A6D483C2FDC8E75DD7BC90585EF32D20ED75D05CFF4315512746ACD
+ D46F65E20A282F32938C7880C4663BA7180058CE8BEC7F67FF99DC45ABB6B757
+ 73DB2FBAB18E5886FD5FEBD39CECD3B8D3C9DD1DF18CC6CE4F12D25E0DFC2B7B
+ 960446F14705AF30FC04BE183728367AC50D3D7551976EF74A057434E553F8BB
+ FA2DC7EF73BB9D87FFE25F33CB641A3963F090C15F9BB2120DEC987BD1DBC708
+ F7D5586B4083291362ACBE4825C316FB750E7E15D5EB2719599079905B4EC1C6
+ 82A1B0AD72033AC9F7084E0D51BE64AA45B585D1525D0B248AA12DB1BAC73423
+ 9B887481B24FAB559734F7C0C7218E064390FF68E05494BB9B285F8174D7E032
+ B691B2DA6D9E355643CCAC4C8496A20967FF7C85194FDA876EEC9F36F602F8C5
+ 49F6F27875DA2DF95A8AF9
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMSY8
+ %!PS-AdobeFont-1.1: CMSY8 1.0
+ %%CreationDate: 1991 Aug 15 07:22:10
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMSY8) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.035 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMSY8 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 0 /minus put
+ dup 3 /asteriskmath put
+ dup 50 /element put
+ dup 56 /universal put
+ dup 102 /braceleft put
+ dup 103 /braceright put
+ readonly def
+ /FontBBox{-30 -955 1185 779}readonly def
+ /UniqueID 5000818 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052F09F9C8ADE9D907C058B87E9B6964
+ 7D53359E51216774A4EAA1E2B58EC3176BD1184A633B951372B4198D4E8C5EF4
+ A213ACB58AA0A658908035BF2ED8531779838A960DFE2B27EA49C37156989C85
+ E21B3ABF72E39A89232CD9F4237FC80C9E64E8425AA3BEF7DED60B122A52922A
+ 221A37D9A807DD01161779DDE7D5FC1B2109839E5B52DFBB2A7C1B5D8E7E8AA0
+ 5B10EA43D6A8ED61AF5B23D49920D8F79DAB6A59062134D84AC0100187A6CD1F
+ 80F5DDD9D222ACB1C23326A7656A635C4A241CCD32CBFDF8363206B8AA36E107
+ 1477F5496111E055C7491002AFF272E46ECC46422F0380D093284870022523FB
+ DA1716CC4F2E2CCAD5F173FCBE6EDDB874AD255CD5E5C0F86214393FCB5F5C20
+ 9C3C2BB5886E36FC3CCC21483C3AC193485A46E9D22BD7201894E4D45ADD9BF1
+ CC5CF6A5010B5654AC0BE0DA903DB563B13840BA3015F72E51E3BC80156388BA
+ F83C7D393392BCBC227771CDCB976E933025343478F7C50B4A98A7CC2A3183D2
+ EA771388AB9173A989BB9C6B85B2018E3A3060B1E1D136A650C4CE2F172B364E
+ 0B1E91ECF9FC28E8DE1F69192D75C60E816BBA4F0B4ABC1BFD7DDEEFAA721C4C
+ BA2218BD37CA4C1C88A98622CFD8D86917C6097F0EBCA23D7545E7DDE207473A
+ DD9BA6DECAC4AEA649CFDC7D644C01C2073307A578278516568552CA7791B71D
+ 61B7C99DB4893362B1D0343174FC4B96118D359C3ADF764384DBB89860185DED
+ 61A3C61FA481FDB410A57A3D7F62ED3A501D2E60F0E232933D4F9B84E174B3CF
+ BD0965C8166E905AAAF1671AEE1B0660F7DD02985EA9AB276B004C158B9D5BB5
+ 82841A694304B156DCBF00D15B503ED5812667591EA6C829211A15256B8BA417
+ CA45B52CA0EC733256DA9E2A9AE7FF6EF776086FA94A3288702BCDF3AEC71F4C
+ 969C22E88B2A43825D39A560493ADA3AD37AA8AEF5CF2E99855FF303BC8F25F1
+ 150F2A762EF6E1BE8B507C550A6AB76C3AD00AE8D8523EE2FCEBDE09BFA04831
+ B48550CC1BBBB2FC84496E09657498DDECF192D90612C90950B439756315BD3D
+ 4B00A104FF58BF69D1FE6C7D71A41AA5FC5BDCE0A21031689879CBF59D755FBC
+ 0168E48CA6AECAB8A2482F2E48D8BD5C47C2DA2B5142FC4B4DCBC4E87EE4BC66
+ 4245245CB0F55164C0C23195A062D13C48861FAA83CD68A3FD03FBE71FE81686
+ 26B85D52432DE5685FB4C6F114224D5A59FDE0A91FC0E251B8E744DE085F9359
+ 1F084F1A6035CACE8FC15A2B302C024A775EC05126A96A8863794A3F608241E7
+ 598DDA876BE263148A4BE026059732BC56B16F9C2B4EC4D3404FF8A999331491
+ E1A28CA5059BA44CD4099844E02E444B565F96D8A3FC3F6B708C35993F358018
+ 34BBFA118EDA22A094B8A31B297AE3CA3FFAE901BB5C212C3F89993F4E8D1D8D
+ 0F4F00A521112F4224624539064EDEB3FDA451FA7D3E1C34EA86C4C395F0C7E4
+ 0DCD72FED040DF68A055642C654D4AF44269D8A94EE4CAA6CAA4C5FE46307FAF
+ 0F8E99981E0A4DC66026BA042D29F8D0889D0E472DE9FC62C5C1FC9FDEB6E843
+ 405E425A5F291B4E52F1459EFCA0DC3879AD52713919794C47B4FD6702A42081
+ 2E31DA8DA2EF7BF94AEDCE56D40D73043C4310EADC16C74FB8DE4F5136954E03
+ CBF3D90D6D3ABB1F461D28539C1728FD151C33CA4435E8CD44E18115192E5DD6
+ 623C66C0E24B203CFE04BDCA8A12409DBD237AD5E540994D16F14F4E17AB113E
+ 79771264A495B6C5BC862DE9A59DD5A1CA6EE20833081512F9FF14551B69E22C
+ 9F07A45B864B5A97C32F79625EF5B478CFAA9967FEBC09146C5C3B8518DBFD27
+ D4419954419A9F9F5D1D3E567F37382C9E52C24806D4EC39AE0B15933DACC066
+ 2779BFA3C6FBFB5F613B43E319B6522DE44814FBB11FCD3DC3AC54D7B6BF85BC
+ B3FF1CFE357686CCECE8C613319F5ADD489DFB011FCF8879481305EAB1186ED2
+ A6A49F9CE2763BE448D947962694FA30A11C07321E47CA6C15B1BF02278D6DF9
+ 344F468F3F192725D9250373F98BD16D7B
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMMI8
+ %!PS-AdobeFont-1.1: CMMI8 1.100
+ %%CreationDate: 1996 Jul 23 07:53:54
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.100) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMMI8) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.04 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMMI8 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 15 /epsilon1 put
+ dup 59 /comma put
+ dup 60 /less put
+ dup 62 /greater put
+ dup 80 /P put
+ dup 83 /S put
+ dup 86 /V put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 114 /r put
+ dup 117 /u put
+ dup 118 /v put
+ readonly def
+ /FontBBox{-24 -250 1110 750}readonly def
+ /UniqueID 5087383 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D6A8F05B47AF95EF28A9C561DBDC98C47CF5
+ 5250011D19E9366EB6FD153D3A100CAA6212E3D5D93990737F8D326D347B7EDC
+ 4391C9DF440285B8FC159D0E98D4258FC57892DDF753642CD526A96ACEDA4120
+ 788F22B1D09F149794E66DD1AC2C2B3BC6FEC59D626F427CD5AE9C54C7F78F62
+ C36F49B3C2E5E62AFB56DCEE87445A12A942C14AE618D1FE1B11A9CF9FAA1F32
+ 617B598CE5058715EF3051E228F72F651040AD99A741F247C68007E68C84E9D1
+ D0BF99AA5D777D88A7D3CED2EA67F4AE61E8BC0495E7DA382E82DDB2B009DD63
+ 532C74E3BE5EC555A014BCBB6AB31B8286D7712E0E926F8696830672B8214E9B
+ 5D0740C16ADF0AFD47C4938F373575C6CA91E46D88DE24E682DEC44B57EA8AF8
+ 4E57D45646073250D82C4B50CBBB0B369932618301F3D4186277103B53B3C9E6
+ DB42D6B30115F67B9D078220D5752644930643BDF9FACF684EBE13E39B65055E
+ B1BD054C324962025EC79E1D155936FE32D9F2224353F2A46C3558EF216F6BB2
+ A304BAF752BEEC36C4440B556AEFECF454BA7CBBA7537BCB10EBC21047333A89
+ 8936419D857CD9F59EBA20B0A3D9BA4A0D3395336B4CDA4BA6451B6E4D1370FA
+ D9BDABB7F271BC1C6C48D9DF1E5A6FAE788F5609DE3C48D47A67097C547D9817
+ AD3A7CCE2B771843D69F860DA4059A71494281C0AD8D4BAB3F67BB6739723C04
+ AE05F9E35B2B2CB9C7874C114F57A185C8563C0DCCA93F8096384D71A2994748
+ A3C7C8B8AF54961A8838AD279441D9A5EB6C1FE26C98BD025F353124DA68A827
+ AE2AF8D25CA48031C242AA433EEEBB8ABA4B96821786C38BACB5F58C3D5DA011
+ 85B385124F430A49A3ECE0D8FE162CD1E248D809313ADB0647A4B4D1640AF92D
+ 60D0A9C71206D2AA79CA0169CDC750998E0EE3D58769AF68248AD003DFD5E877
+ C63CEF7F87E2DEAB9F45EF8B2B7F5FEC382A137565716B4C5F3422A28AA958F7
+ BF6D5FCAB972E34A304A301468DDF874F3021ADFC5B588D1F48B33F6DCB724C7
+ 9D00E5024695893670E340DC4C963B6C71A74F273475FF6C6A32B586484469E1
+ 226D8A835269DC321A05AE1E3C2A4F6B9F699BB28DF3FE8592667D47E1688DD6
+ 2AFCEAC5487A19B22DE03C52ADE0E63057E4A1BD3C1E8200A05FA3971E0525C0
+ 094FF39CDE213FADAAAF8D9105F1D56C518FC7098B1FB747BDB2ADDCE7397768
+ 72DC58CC7D53283FA576C6B014637930B91A6AF4DEAC96C0BAA62BC7DAE80A97
+ D26E800D94E817964B2F88E73E43FA6290E175AD27C63321751FA57E669BD24A
+ 619386E1BAC9A529B68DE18081F5462B5E56D5098BBF3A2B812662DB6464ABD6
+ A8B5AEBC49DA0D0D25B39B7F73A0F09680EF375CD54E04AC61979FFD9DFAE611
+ B73B7EB3B5C8622A2B333D5058DE7E124AEBAB316BA74D988013ABF1B604C3F3
+ 47AEF01BBA20232F1039300F448EF3E0F5E7BE09FD2EC67A0482438379767430
+ F0B6B3FD1A13E2185E9A88C7FF7A59BB0DFC22374F122B3F4CE9F05E8C44B689
+ 3F4DDC94EDA64478BEF6EE2A60095789C442E698A41C1DF9DEE307F8F70C7E5E
+ 038B24A3AEC3FB6A20B1607A87C4647D2D3F6A955C7079FEA178F76E05A12D59
+ ED590112B0859EC00E694EAC6BADD768F15E090DC90388541D86F379D4E66B02
+ 778CD6C2591F2E5957B83CE914F37784E7B23A2146A357D18BDD192F689358E0
+ F1C21B1844EBB8E137301F9AAF92CF054C0CA39EEE9E102186FE88D21922E546
+ BB6D2597E2CA17C058EA8FAD367E0CE3995133557BCD0C328473139BA1416A8D
+ 1F90332A0C24363984220CE4096B3A20B71F0EB40FD2327FDD1BFE7460A98D3A
+ 793D912D7BFE9400444C40531C26BE53F91ABFEB73569E39DA52C080F76E387F
+ F72DBADD5984716CA60B4D66881AB2CB4E078D5B0AACCD25E443DEABD03872AC
+ 2B1E65F29071DC2462F39D9A8FD8ABC5399561855735E62C74AD96E0AB910C05
+ 858D3A649A0B40A48D94043C947DA7FE0767B656E582C506DA0B71958627354C
+ 81C671D635135A1C9B85C26E5287AC0EAEC90F388CF454CAC47D48B3C54AA747
+ D3A0AE3623E6862D6880FAEA92B4104EE85A3A5BD6D903760B63615889383065
+ 873DDFF82B65593A6EE82DE84306A8F5C68535E1D8D2C9C089A332709F7F9F5B
+ E8146C3F6A1B6DBDA5FD267A7621F135DCC364C8C23898085A8FE3BA88DBD52E
+ 61C0BB9E863194F797C666171E02FA0768D26FE7A7DBB0AF29778E839F30FAA7
+ F617E464399D1BC7DAA736255B5FCF2F55F2B1362C5BEEAAB22E20971788F83A
+ 4A82628D01668033D18F9373CA9AA0F5119597C86A8AD27F1370E892D2EBF36E
+ 05FA667BE4A9B2940CB79FCB317DA229597280325EF206DD70C1D30CA211E403
+ DB14C86D197DC1632CE077670A981FC582FA425A2AB40C179304D1C9D714634E
+ BF65F8D8B5BDEA22FEA87CEC3AD00CEDEE47BE44445FB364AA145072C41928CA
+ 5C1C2EB5A8094EED385D343A9273F6D3B56A7AAAB8BDF43D960C8543CC5C80B9
+ 2AB4A53319E83FA5CA8FF424436A76AEBF9DA001EAE5C473597B0E01C9F9D312
+ 35236E56E206D4CE7E13A94B77426FC635F3F6EC385A3B5C977A6070124911F7
+ 841CAD3B4299C856BB25578889E8781D2F13DDC7CD6B8555758D8830FC10D7E1
+ 49FA6E5BE07BF3242248ABA618AA8BE5EFD3B6C07583BA27D83737748A4F3E0A
+ 004A20D7DC545AB3F1F7B512A146D06705502BE8EB6F63F8B0EB3D6786C1AC2C
+ CA58BBE2C16FEACED069729578D7D38CD59F7EEF0C071FA86C372C9C1FF42731
+ 634719E99BF45134E0DF63AC4F72533BF435E754FFFD416FE59EA6A05A27BAD5
+ 059AAC463AF8111A491E1BB47BE85B6FE49986E5860D430685093759093129E0
+ 2A98A60ED52E05F59BF02A8BF298333EC45284355B8CCFF18051DBD01D8F1A61
+ E26AC7080B6D6C73B675284CCEB262A54C133BCECFE4B485FD5C2CAE6D897203
+ F1D8A8CF1B5F5A790A64C319722FC8CA3B470F4912D3F50EBEFD2E517BCA656E
+ 625FBF218CD6ED32761A1A05BCE068D83FE1A3F28AF26EAB2E9A4B7DE91E4AC6
+ C871C4A122BF8C0FEDCBD02F52C0DA0EB6DC39725905AF8CEB68F5CF3AA2D5F8
+ EF7141A7C46689F448682E98FADBFF341D43A5818D57F278C0A08E71640FB394
+ 452E9837DEF24A18C172E52A7CE867E733250162D21EADABCA84E0171DE42998
+ 3BE658F942171591622D16FDF21911C22477B91D6890B2FD162218C8ED630D03
+ 7C1BA18E232F174314000004B7F8A546FE1F918572275200DF2FCDB5BF5679D6
+ E35209E0131B71950A17FAB93736F6FA74E53C3C433B7E7C3738F1567BBEF306
+ 8E92295C3F11A6D74D0054731AA489E88FCD9F6161C4F89C64D6BBEB655D0B05
+ CE452051968DBE827FBA7B9B9EA250F5C629D6A5E0F9318FD5D58889527B2D58
+ 92FD4850AA2E8E38B67DCF57561D65AE0C91033259639371A953C3359ED3AD64
+ 0A25F549BDDBDE8FA8F019AD6C755AD30CECA261841CE063C791EC5D57D41FB9
+ 0DEDA4065BD1FFCF9CCC16FF6439445F96C91A85DF5FBA69C7F5B3D861785604
+ F6CB79D732761F94526E00A9E05498F3CA5D35F343D8F005E5CDBFA870B03DE4
+ D3D940E68FEC8D1E98588754EB52CA96349BBFBE8F8CAC627F9E946503B74B92
+ CF3E3210B0142F518484D1DA8866DBC027FB9D07F6AFBCA4C5F17E96CB6DE4C6
+ 4C9493F04DE26A8DCF4D8E280FFC7F8B2E1A3711E40A0726DDD6CC0C81BF2D5A
+ 47ED0C2746EC16030F9F40389BECDED2421B564C3FC858EFE40EB6B8F35CF197
+ 9743F45A975A7EB5B9821547CD82755F0E2FA20DC51CC7BDC3156D518F813B48
+ 35E30E092DBFB8E29DE880039419C04975B1120D2B6069B711FBDEBBB6FC25CC
+ 29DEC33ACF54DC4D986BA79DD9AA47EA9001EAEACD2151459D755FAB53FC7CC5
+ BF6FAFC5732816A73D35D9B47F1F3E78DAC1BA6B375BD53DA1E8D288B6F62E5B
+ 2CC5767632F4A396C57F10C59EED6CD723ADC584DBB4E283AC4CF75ECED8DBE3
+ 49FB569DDF4F5DFB67D30A5A29A45FF10BAD3866CECF06B66B985B8CA884FBE8
+ 97C5E86A21D3F4395F7CBE559B662A288B92D1A1915A280963636F19CB8958AD
+ 929CBD97E3C2BE29DF999882DBA1E235768507024943A558E59A14A77734114F
+ A9171A796A8ADC2E056B09BCFF915D6FEC0FC89D
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMBX8
+ %!PS-AdobeFont-1.1: CMBX8 1.0
+ %%CreationDate: 1991 Aug 20 16:36:07
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMBX8) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Bold) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMBX8 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 120 /x put
+ readonly def
+ /FontBBox{-59 -250 1235 750}readonly def
+ /UniqueID 5000766 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F05C11F9A72F5DA508C30BC4BF52C8B1EC5FB
+ 7F9DDDD0964A6D59193A389D490DAA6F6ACD02CF71C06802F3AE5A001F2B3A6D
+ EEB60E9DD26DBCE1D29C825A9BEFE3A6572E70DC7B60344C3E0C9C77ABE1804C
+ 7ED61C544F0B4A3D6C7662DE8575C07BED3F6DBA7D64A9C8613AA152B74A140E
+ AAD9B66E0FAEED6AF9D1820F361C1269A5E90519A3E6D40782E06778C0AFAA30
+ E8CEAB87054C4D156C1B14B4E8471D78648FDAC70A3B8ED474FA356393A77420
+ 4211F60E397D2FEFC6A8D91A80C84EB9E38E663249FB91D5C8A5CBA68BA04272
+ 5D5D42497E1CF5CA1E62EC2B139F5CD4D6318EBBA7AE28614D2D88709C2A3762
+ 611524B8A1FFC7B0FCBAF77AD8159C354F4887DB1A27781DE0A4BA7DF2CE2025
+ D9278CED48584E8E6BDF30BFD24284BA1DF828B637BF84A02908BBCED67372C9
+ EF44711BC2B1DA343C8D9D27A9745525C774F5D639B7AEC197CEEDD06FD27923
+ 35ED0D402AEEB51134665A47847429D91CF419CA9B09DC905F610F8DFC54E606
+ ADCDA19D5CC68A7BC7108EC9236C64205B23CE68B9BC38EF3E5BF9E0E6ADF404
+ 7365C8D0436609438C82EEB2F356F79186DDF6C1C797D3C278108B1767D15178
+ C4C3E8ADC2482BAB9536AE8419E5CF3EE1B6E53BDCE2A83E2E485F496A562C10
+ B3F5A131BB19D1E5414C86C5F995521076340536E10613E42779FA15EFDB451F
+ 53495CE8EFF239E4EC442E1439594549D45F5276F93D496C9AC712D762D0B702
+ E894290BA028837304AFDDD8BAA6564E9DC307A14A7A206550FADDC7784DE3BF
+ 3390188BBCDDD929C82B1D7B529553BA75ACF5B385D31EE3902D96B2B5DDFFF1
+ 9F0F90FD791E54128C1717F313486896868A34FAFF22E23CEF046D02C145D592
+ 0DB895D08954C3ADB4882C48160306B81B690E84DD8B9A325024F412A38226F1
+ E73826B702086EE5C70FC09EF3EE9D3E163FC2EFF20EA91B0FDE02779CB4BBE1
+ 253409AAE0675CF799DB4C1CB9C35A904148D31D31EDBEE40E163A4E9265A2A4
+ DD9D5A45E3AA4D1B0825747F59431D7C097D66EAEAD96A18B1B45FBDD8EC7327
+ 88230A6EA5429C5A1EA9197C72F8EA9FB4E1A342FD0D3EC90F665F9256A2D4B2
+ 74BD3E5BD9CC7801D8DE5519056A0813A63834310439DA1C8FA3C3FEE98E0206
+ C34234A6545A342AF0884B6A8C25533242969FE8D1A68B9F2481AD7CA8713907
+ FAC689F07969B11C72D68AA83C2E182064F307B4727DF21340049EBD1D4DF598
+ 08321E9CF395302D9825A4337372DC0668889F66202344ED0A21D7223C5724A8
+ 6FA131AD7198963731BD25E6CFA1936685F86DF549EBB41417FFB8DB5F142F22
+ 8C87871AA4FC53A35946DCE6488E46249DF3DFFDE479F0F830A70036B51CBD48
+ EDE0AAA5186671454B3393C4542D8AA32F813D855EC8AA1E4B6E7E940CC538F9
+ 2842E223311E0A6EE898BD0FBFF7C713C718CFA6284D469C2165D170626C7C8A
+ F62B527A858ED612A157E4D5219AF626305C2B8FD0659C93ECAF50D0B50EB84F
+ 6420F9C6D529E4D4533043582783434FC0019D00D89A2812BAE172DB6368BFD2
+ 3AD83CAAF5CF597EF0E6F57DE792161EDBD9A04CDAE40D329B132413EEDB0CDD
+ 1B6CE99774C7DD7CD739E98C61C08DA25C0EFD030BE4735B620FD8C422972A74
+ 8EBE7A4E5A2FFED8F72B8131C17CF9B86ED3563A64EAB81859B521299D83B997
+ 1A3353DF32D27E95FDE4B42766B427C2EC5258F6C33904D9C3BDCF5D977312EB
+ D5CFAB0D1DE21AF10C0087B9FE6A5A14D4E8759443D916E89E0B60B339C06085
+ 9DF9B75E6EB17858A9724A10E09813B72998257CF8EDA3A42A6C90B0E5E19B8C
+ 18923141C846AC0A3277C457C3DCB7BF1DFE9E1A6FEE80B1291CC12E1328F37A
+ 75930837BB5542ACAB5D8274245F5C4621E19E2494FD6134D163B71E177A879A
+ F342E8FBDA0DFF7658DF35F8970C86DE88C0A6936CA2B53D930D7C5269AACAFD
+ 5B46AD535DB3213519263FC1C22577F3D632BBB09267CF5BC9BAB29FDF3181A2
+ A7C12A728672316BD32601ACFF3E7B8C8B913C2C0AC9DFAF4A58769CCCF7BE6D
+ 3337E4FCB5B1221586F0B295149772E658A5F3FA27ECEA68ED58C1D4167AFFE8
+ 580A0AD37B1CDB0CD4B283744E9B3719389DC7B04A11B8891461C1D4382A248D
+ 0DC9AD4235502C287C6C4DA5383B8908D462A0396EE868551FEED6CC1E768970
+ 8A62B9D1517B70BECF0C6EFBCC3F9B206324A0AA1857A3C898222A34DD3CDEB6
+ FDF66D4248113BF186ED540A58236AA5560A900D9077657AFBAFDC4D73E76E10
+ CF53D09758B1703D59DB4DEF4A1E16CA5879250581CDEAEEEEE124458BC7C2D6
+ 144960D223F69C578F87B5FCE270CC37629C84D1B972C35DD566BB15B2B79B27
+ FBFF09E8E9E18660EA0214014A4C8E9EE208B967DB0A63A22F8702FB029E644B
+ A21D1945E208ED242FED12A8C6132B29861DD540A301EB6D66FCADCC66F4BBD7
+ B7CA0120C4344A7F7A3A32A6A184C3FF024BE521BF06AD67B21C98C1CAFE9AA4
+ 7B03D41EC43CE8B35068786A3E50067C32620CDCA46415011B95B10DF1AB67A1
+ 79B23B4F698F99576A40B021828CB206BEC4DB7DFBFEA06E75807E15FA69C538
+ B854BAC30DEC96B65C7A0BD7007374BA8A5C25A8C39651ED4EF09CFC2F1A8A9D
+ AA756E61DDCAA84673553FB433BAC269C59D2C0B292A02234190B4C6A43AE995
+ 2FE4032AA676BC026AD5F94C20EA12A6645A37484957D7E87B801C632192ABF4
+ 7BBE6F7EEC11B168F9CEDF96B3D59FA481C3646FA16103B2D44D537236B0A018
+ B3919061FA585704B93760E0E4AC92BBCCCB0596E7BB3B44C9201A8D0B8EA897
+ 035B737C9298AF0316C492316C2F75446BAC0A0EF54C24A8588E29BB90048FF9
+ 99515D21DAD3FF1E1C73DA14BA0D74A53A925BE3751CCC4F17458C2DF06DA1DD
+ 7FCE4EE7F04E5B27AC52E96E98CD36EE3D9054111D66B5D47840E073BEF40589
+ 26D319EDBF85C8BBC3C583C0AF92767F17B7ABE793BE78F773BF739F60A6A381
+ 44CEAFB8D534CF1545D34D14717ED50F787B97AED5D145ECF7AB929303A1235A
+ 908F4AE5A401B3D817E67312A55145B3768C53A890A1E7BE0EADB194266E0010
+ FF7B4DD39EEAC79A584FB75432B963FDFEB74FBFA4CF739F73E4CCB0DF8A76F3
+ 0DEA972F204E36EC4682BD4092786715E3ED29B6C5022B3A59BC66A76EE7CAA9
+ 9543136A5A2883780BAF739898B252BF0AB32B9486ABF69CFB809F7356C162B7
+ 3E8456DB15FAE69A3844D8C1AF8CAC46C54596FE16DA5505147E0B3173CB3B02
+ F375AA3A0A46B024B473C1EA8C01D246D76EC3FF82067C197B95B070FE19E7C2
+ 195F18199429E1BC522D8A67AAD6DDBE90225DBF504D117E308EC2D7FB5FC345
+ 43C2F358127D56B6D2844D4CEE0DCD78CE34379E20DBC1977BABB384B261F860
+ 9267D97D7C011DB7E3F2103EFA2876558EA3B4513743702C9B18EFB30671CDD2
+ 5C667663BCF2F944DACFB2C4265175FE5014C183F1654B10DD9621928D8EA677
+ 899C5DB1505141C03ADB8768BDAB7385DF40F4642D12C42F48D63CE893103E39
+ A9F3DCD02242FC1A849BF05C5A63B6E7B78F44421C437228F17BE7EF75B8B919
+ 513B2BB14F01939DEEA6CB8170D77EDABE045F57143B3091E19ED8176B0D14BE
+ 7F8BEB6C489DBCF53139D3D32427934DB837590EDE72936AC58751D9C6F6E514
+ 5A753D2C131728497A677917D7643A1ED0011DCA3A5A359BE329D0A415BD1477
+ DCB8FEA60D330E1EBD76C6CAC1AFCAF79D3675AEACCD3629A24156E7E38F9D6B
+ 9BE88DE072B56B179800867C2762C1B139D6BBE60B2EC3594AD2CEACC5966A11
+ 4E4208FA27DFB959A47B961EA0E6CA1F28174FAAE060376609D24FFCB63209E1
+ 1F535EFE2C1BA8220BEB3D7F03311FD77E7CD7DAAB5BAE677CC8C78A885A2F73
+ FC872738F52364C0249B51209556B4A9EFF0FD18D329772416BA790161DB1060
+ 74E43177F8B681767A1810B14B4B9F13EE6D2186C728E4021D9579D77DF4E438
+ C3A653BBD8D82BEB0FF630D137815B3F55A7294F4F4EECEEF477142BFDAD1F93
+ E126098BC308BD235AA663AD020285C4126BC16F1B780B9AB02310C609E76C2A
+ EC389E1FBF3CF26E862F0DBCAE6D1F034C909E2B603A57DA314F225811E68052
+ 0FC197B8EA544554002CA969402E703BA4976880FCE71C4FE1252A23EA480A0B
+ BD479646234A6D94B87AA6A43521848C69B74FC16EEE9B3DCB3D4C4968D2C72C
+ 7ACD98F79EB6C8C05A4584BAA2C35C4301999FA52FB1969A43AE9478D76B9D93
+ 7E611292D7677D006E66CE3E8C9397C89DFF5112DE3AED7487511E99340672AD
+ E8FA257EE05B58DB4BB1AA7F82581F3AEE3A42F749B37FC34535B0D67F925022
+ A86F2525E96F703D1D470C497EB401B60F509A8A8305364A5B1CC98FC0324B67
+ 92EEDA4357E669427039E3CB18E829E1176BF91DDCC1414EFF5228C71DFE1F51
+ DBD024101ADC1D50BD21F907C575A51B8097D0AFBADDA5DEA95C795EA3067F9E
+ 4C2644ED9A294493D65DBB76C8EC37A8EE65CC0564B983117AE6DC65E95E7E6F
+ F97A1DDE7284BD710173FE7F88BA181CA04E4CE6C38155B293A57A4B16C4B29D
+ 1A9C28DC2140009A9F19208856DBAB01C7863C00577C5EE6477390DAF8D00CA5
+ 3D199D1DED7769E9FC88A0A4C8E6F65C248F86F36695C160141A3A4366F34F8F
+ ACB89922B9A5483680CB385CF274BE8A20F3EBC98448A1205B0F3454C7FA4ADB
+ 24549A0EFC42E1FBD8EFCDDA6FC8396D744CC560F77877FD16E5249E7F3749EA
+ 4FB8C6346BF6A5820F44334CF9304FA41B7512E1FDC227EB9A2C546E76D81F93
+ 862A5620C16CB18D7139632056D1FE413141EC3EB18A79634679B8C39D414C76
+ 4F97FB1E500453C235E507D841BDB81A97045D4CF62582AD9F43D497249C5008
+ 4B9DBA54F6C980C711DE0880DAACD7B91A6DF5B79C5CC132E29022707C4E5610
+ 1D642B40849F3661A9F6449ABD5692DA3F62D230D93BA68A5E02928469B15806
+ 7A45D033A97F71B6BDBD076D3D54E19218E1D5E8D00AB56FA1CDB4DE42221CA3
+ 705CE5D9AAE2134D05526328C60A88953B0CA717D00364665878E67082D8225A
+ 6E31C2AF3C00A96AD88794D3155700D0B570EA1ADE2BF8BA6AF0A4826E265561
+ 93D21C3077505F3E6FD40797D363D9F22078CDF841B510CC8D19CC0C6038FB4A
+ FE28720128EBB85E082FA33250141AC84CF0B7AF32581FD31801EBCF761BEBD4
+ D6C058E28B39049E221A61D9557A20FAD7C571AC895447CDD74E53FB5114F09C
+ 45444644C55CD5948ACC79F11AADA61E4F687DB26EBE7A2D803B7D89CB96C34C
+ A8C98E3F098F668C250309F76FB21775F7289779637AEB8F288A0B8FD0FF2567
+ 957C8FDA2081EEB3EF2096F8E182B647AAFEF27C0187ABD08B3CC2E2450F8721
+ 128939E640E053E9899E308725D294061973A5FF3A66507B28D3E6C1A3959EFD
+ EDDFC5838DDA3F66914EBD1674ED170AC812D1E21DB964DA87F64116624A25E2
+ 6EDFAC666029CE933F19E4C6944D0CAB8757FF4E068BB82CE3518A19C34618D4
+ BF9C7A1AA7D5672C607E5FD4D52AC4AAB7BCDDCC7E8ECDEF2EC1526DE5B9D623
+ 0059C3A9EF6A5957DBBA94A6C740EB3C2A868500985EA7E50260A389AF4198B2
+ 062ACD80B05977ED7C12561C0542A0157C0A1A5F48E05B07F74AB7C079FF2CCF
+ FB09ADC7C8F7494DE5B5B0BAF42A85F244F9D7636F715B9F636110CC8609B481
+ 315BC7EC1BC0FE2193173EE9
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMBX10
+ %!PS-AdobeFont-1.1: CMBX10 1.00B
+ %%CreationDate: 1992 Feb 19 19:54:06
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.00B) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMBX10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Bold) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMBX10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 12 /fi put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 65 /A put
+ dup 67 /C put
+ dup 68 /D put
+ dup 71 /G put
+ dup 73 /I put
+ dup 77 /M put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 86 /V put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ readonly def
+ /FontBBox{-301 -250 1164 946}readonly def
+ /UniqueID 5000768 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F00F963068B8B731A88D7740B0DDAED1B3F82
+ 7DB9DFB4372D3935C286E39EE7AC9FB6A9B5CE4D2FAE1BC0E55AE02BFC464378
+ 77B9F65C23E3BAB41EFAE344DDC9AB1B3CCBC0618290D83DC756F9D5BEFECB18
+ 2DB0E39997F264D408BD076F65A50E7E94C9C88D849AB2E92005CFA316ACCD91
+ FF524AAD7262B10351C50EBAD08FB4CD55D2E369F6E836C82C591606E1E5C73F
+ DE3FA3CAD272C67C6CBF43B66FE4B8677DAFEEA19288428D07FEB1F4001BAA68
+ 7AAD6DDBE432714E799CFA49D8A1A128F32E8B280524BC8041F1E64ECE4053C4
+ 9F0AEC699A75B827002E9F95826DB3F643338F858011008E338A899020962176
+ CF66A62E3AEF046D91C88C87DEB03CE6CCDF4FB651990F0E86D17409F121773D
+ 6877DF0085DFB269A3C07AA6660419BD0F0EF3C53DA2318BA1860AB34E28BAC6
+ E82DDB1C43E5203AC9DF9277098F2E42C0F7BD03C6D90B629DE97730245B8E8E
+ 8903B9225098079C55A37E4E59AE2A9E36B6349FA2C09BB1F5F4433E4EEFC75E
+ 3F9830EB085E7E6FBE2666AC5A398C2DF228062ACF9FCA5656390A15837C4A99
+ EC3740D873CFEF2E248B44CA134693A782594DD0692B4DBF1F16C4CDECA692C4
+ 0E44FDBEF704101118BC53575BF22731E7F7717934AD715AC33B5D3679B784C9
+ 4046E6CD3C0AD80ED1F65626B14E33CFDA6EB2825DC444FA6209615BC08173FF
+ 1805BDFCCA4B11F50D6BD483FD8639F9E8D0245B463D65A0F12C26C8A8EE2910
+ 757696C3F13144D8EA5649816AAD61A949C3A723ABB585990593F20A35CD6B7E
+ 0FA0AD8551CEE41F61924DC36A464A10A1B14C33FAFB04862E30C66C1BC55665
+ 6D07D93B8C0D596E109EE2B1AAB479F7FAA35279ADB468A624BE26D527BFF5ED
+ E067598E1B8B78188FA4BCFB0B51692D07B0BEBB930C6F0997B437E2C51B876B
+ 61A563A2673932C2045833FAA35DB22ADE12102335D5DC734AE3AC5EEE6658D7
+ 92EB62131E1DFBA441F53EFF9021D9D4C491F26BE8F54C61165CAD778CE8695C
+ EEAF70E3B20C64D4C2B34A084B5770BAB2A974E898F62BFE90F132A37E2DCA4F
+ 43E13DB13C94DFA8ECE2B7374827AE168634FA007F8981ADA046CED3448BF453
+ FCD9A4F194FA648F9FC0971734BB69CB73439CB0DD021D44A7C11BF295E81733
+ 4DFBA460FF3D654F9FB337E99E6D66FBA87A817EB9CA1536C84833870E3626DA
+ 55D48DE850D3E6F6B29DA0E7C9D681283586F208DB8D58042E3A7CE55BE84822
+ C98237911453E479EAB65AFEBA3F61A763B40E74535BE56C9D8D06DDF9441741
+ 5C9D9D917439368736619717FAB4F06E2C329AE0BA411F3FD522D9C33AD8369B
+ D7DCC9DF993778482F35F965973DE876FA19E109AA198A00658AB3F0D8E3DDD1
+ 08A573F2D525202AFC57E05D141E6C0BB811E1FE280EEA002B7A45BB363AD06C
+ 318D320D2C81AA5DCC842CEF66E7DF7670588CB39C9F42EE7763A3A17372432A
+ 173BDEF7ECCEA297CCDD76A835C36DCE9DB8F8CB66CC71B4920BD5657F0064D2
+ 4DDE0E0560100742C0C991B2788E8AA8194A2EB60417F290A52AC0F54EFD2632
+ 3B99F188D4A4A90B26C662D77148637DB317EA3227A72D7227088422DBA7BCD5
+ 707B6615D91506C48D8F81D16738F39D5A7D6BE28AB7A3E598350A470C355EDA
+ 14CA5718A2D5D8FCFF53AD50BA0348860DB37FEA96B808391AF63BA9AF46A01D
+ 38F2F1F69D1883BA14B4710841BE3B84BFCB5CF93030CB2D3451421A02FEFB25
+ C50B2402F2E679FA16D3559C58D01E8E6D9649BCEAC3802F2EC8629A8176DD65
+ 498E1C3D0B746E098E7859BB44783EBB30B06D334230D8F8C47ED334C81C80CA
+ 9A6B61079089AF5AD67C4D532A32549EDD3A7EDA4FEE2B53B78DE3580F500926
+ C632218410359935190AEA72F203588BC9CDF7720B9289AA85899FC97FDCEEEF
+ B1C07B0D2F8D6DFD02F38FCD0A3C36F5DD4689C01A9E1F6A47FBACED7820CAA7
+ 56084F6865FFBB71ABB2CEBFDF5AC8B058C3CF49083322176390B799DD80D853
+ 89989FBE0F14B15FDA50793D3D4EE83722C5AB2D8555405C733491D038FF2497
+ 63950EC9D47629E2ADE1D6D0CA542D29777B876DE81845AFE32EE03863597815
+ DDD9E59B76D05BCA5AE9A9D9B585F9D103305CB37700680D042479B836150009
+ 3877837F1A7ADE8F840B3FF617BA03B62CF71D52FB481628AC154BA0E2794308
+ 136BD56C2C2783BE564AD1821851FDF56A1293A13EE20487487D4DE11410C601
+ C40F661571CA9C59C2F1E2FC89CA5E0D6C7B1C728FC498D5C27DD74AF68984E9
+ 8030FE6B21D02FDCEED2A85F7176539A142B166A0B1702A689BC2D38F36B0AE8
+ 2D42294BB211C6E38DC82512E4336F12AE5A939A728C046B84B147D3B3892045
+ 6A7D79BD8EA0B064EF14C669653885F028D80A83C90BACEAAC539F7AEAFF124C
+ C58A9839C9E34135D82B517B9D31404B68B024B740AF9C125B6CB95245008333
+ 9422E70EFF6DEC3B7009CFF3E34169839FAFFAE0FA51A9D35329D523FBF9110B
+ 4CEBFA3FF0B82B98CA9B6592B23DA3CFAEDCAFCE0B0560D3FF25FD1238DA248D
+ 799EDA6556DDC7DF7E097E47D26E7AB6A87D7ABDBB7C45649A36F0EBB8D7532C
+ F5B73B808D7377CDC35B1E3332930D0E1BFDCF3FD427F6CA6941F05AD5D0C3B0
+ 8B2FB1C407BE71CC74402709DBB4309A7A6076F348056235A9AF6DB2506A92C5
+ FF83D844E0DC999701CDD72360C2FF6A7910B3DECDE980B2C4613CE73ACC3684
+ A5F5DBAA9221868D652CD549BE88FC80C3DFE875F7CD94829C80761864716114
+ DBA10CE2125C0EFE09C5BD9071ED62D6C87012D6C0F4BE26EBA90F9BA1806521
+ 2EAA2A6E63503539575A6F15CEF6F6377537ED77C1AA0C7A6F76A4FA39581EE9
+ 512004A0832446C0DAE8B3852C13547426DB4762B057D5E55F517DEC73D896E4
+ F6241DCCCCD0933574ADACCF2BAFA2906E0BB7F8A19C84D7C335278E4881B23C
+ EA179FFBE0005A63472A0B8CFE3E930FB15FF7912319CE5C08D2709678F2EC12
+ 587190A32E60AA79CDB0E3FB3675A45B1EEAF818906B0C84B86D0688F8241B93
+ 7B201688BE8121C0DDE14C1602B74CFB5D182DB679801F3C036D644026341108
+ D66A77BB48A8604FFE53966214821E5250C2CBAA9A68DFC1EE5FF3ACB6F7A074
+ 065E35D41BD921F60B9240F2FE39AB84D27BD1B805F3D7D8AC9A791A65B9D14D
+ 0E37CF62FEAD6B0A4C77A19CCB4F4CB4BBABA533C055092D9CF2B59AAB0829E8
+ A4626E71F2091C224945E4BC3E0D69AD8B41C0168B641F5ECD8EB7F33DFFC29B
+ D6D8E2847F8DB64675BF32FF17B076F7E5596761F39C52460BC7D6DE2932EBB5
+ AFF3F0BB187742928EA022B8C1905571DEA845A7F39479AB3BE2FD68FCC146CA
+ 843737423F67016B3511EADF599C423F78696F4CF4085D0BCBC45CCE9150F2F5
+ 6FB9E0F58E2C5D6BEF417F6E737B712EB0E7B01EDC6352EFD4966DE4EC86DAC6
+ E1193415ECAFFA039BED2CC3481D8BECE7994C17CF31C6CD4B954BB6956283D4
+ FFE31CB040E92A9DDF4EA81C1EA49B8E2080D99C71CD1C6DA5400EA9A33F1C7D
+ 5113315402D98665E63D5FC952D7CFAE9A98588EF7BDBD1F606914BCFB6E01E6
+ 5D29A4945D529AF5A7B34A65C5E5EB84FF8E6DD3CA9F7A577816217F470861BF
+ 6ACC2BF630EDF8FCE2CC22377915067DDF3A14EEEC07DF653F285BE23AC01045
+ E66291913CF567454DBB7354B06CF09D58948072C47C7A8E2E1F6ABD7CC49047
+ 858062326B3FAB3D419F590C795B3D855DE979E5DD5FFC91316C4AB07F9C1537
+ 74DB3DC74F03372F66D06AF2965C03743261D533103EC31DA3DA85AD10F253D2
+ 4C7AF62AA4843BDDED18681E49AA6699C4867236A5191CC2821F7A08A7B8FF74
+ E70670DB6C70D689CA4DAF85D900524227F9DB8DF88F9939AA96CD8FB5E54E30
+ 7CCC3726D28518BAC92F25FE057C0FE63B5CC8FCF7E1D502FF6D0D935B7EC415
+ 5438D1AEDB54B1FE218947D8112A647BCA45FF32CC60828B953175B95650EB73
+ FAAE12AF8795A55D2EC1FA3401F5D2A4C8521772093866287D2117044E12ED41
+ 4F3A8E53FBB44FF8B2C2FFB5B9D00915772ECED92BB24BFE0D0303750282BB18
+ EDF6BE38DFE636525D6EBAE92997AD03D67F76A10A61CCF4E00AEAD4BAA66258
+ 22B34193C8CD38BB81D391C2470C7B081CF116976C672EF12152CA45FF4E66AA
+ 5284269F5336BB5E755A3D450A4BF3A71331C6F3636902ABAC198D2DB7C62E02
+ 41A038C0FA41054E97272AB2DBE6405F30758078F2E0B967DF38613F053765E6
+ 20CD951DC8980B808A881AA71F3D6E8227CCA0BA23F5EBAE77261FCF4360840F
+ 251908C887CC8E627A1CA34BFFD156DEEAA872098FC354C814018E0C6BEDB866
+ 2DAD859C28E3A08BEAB321C434DC5827E51153BE40B11CDD012EFC7DC367726A
+ E029E1CDBAB11C6A8C380F89DE454A6097D61E3CA748CC46D294762405C92751
+ FE4CCBA2D605680D806A1AE8E2F9254FAED078B8C4B2D2EAA1232C0153BE36C3
+ 0B1E57F8181720BFB35DAC4DF444AC10778AE89A993D60B97851E7BA85D260AA
+ 96BD6A19F8F08923EE283DEC242D8294D7BF1064993547F9EA04764308245BAD
+ 7CD73F8980FA59CF319698BB8AAD5CE1012C279318C02D0C54EC914061FF1F35
+ 54DD54394ED8193297B8960B041AF6D3C1305224DCBBB7ED30090FD7A80A012A
+ F3C0BBF46045B923B6DE494C11DB23968B373C295B4FEDEC019B5F11BB46B92C
+ DE5B019403E0A47EF406EC19827DFB9B02E28EFD9AC0127118824806F0D1343E
+ E750A46FEA67856879BE6FFC2DDC87A489CD823CBCABC1E06C213EF3B56AB8B7
+ 432384554D1D490CE591D3D668AD6E0B090E0A87DFA691B0961E180E87A40067
+ 1E16A3EC9CA6C9BD393C2B88EE1BCC9872FD6E25F90E14CE3D722DCC142BE6E0
+ 670276497BD534847968A8684D4DD886F02086989DAD14804859C9A6F811E5C2
+ 7B5B891666B49FD82026D9F7EEE1DAB5B61C31523E61212709F008411C7E05BB
+ 800928A607D557794067669F67E3E42D292B6B4944F7033F25CDBABF9EA75FAA
+ 5D1F5A45CF4BCBDB633BCA85836BA5B342725628BF5BECB46A65C910A6314142
+ 78A8B995ED9DEF00BE46F7288AE1C96491112A14B9FF23EEA1B6DEBB24CCFD14
+ 4624301A7CC435F17AC9139047D87D6960F91261CB77912CAA5C809C27EC0411
+ 95E3720DA8B6C580A802953AC64292E92EE0D0A6FA9514E240FC3C4EC38870F6
+ 0DA6BEBBE61ECD13BD10BEC2E065CE96D7695576CABC9B729B3E816A464CB9F4
+ DD0DB91E1E3CF66F1067BA72168262DDCC6D06CF258BD502B94BEC6A1FF114A4
+ EF8CDC82FD026DE6941E079566BC62B7459425637C73A8590576E3477059C3CB
+ 0D43F5BC84B7DE8A9449D4ACCEDF7CF6AF1D0AFDFDC4FB94EBDE8889C3B658C1
+ 4574AE7CC8518FB67F43D5B9765EAE1F21ED6E72E3DD07B933696B79C2843351
+ AA94DADD49B18C38C13A312888E81C9572CED7841A59D5A4220C82613C4D8E6C
+ 34F505095F8BF51C67E4A2111C39E41D170EDFBE89E2A064E1178DC30BEE8B36
+ 71D9F106ED943B4F11DBA113FB79F40042C6CC47908DACFAD1A2D7AF9E987FD5
+ 9085DCEF0DB9D75383C0302FB0F88D843D9BF7636DCAE0AF0D9A6A359EAED3B3
+ 7DE451DD8453DE9B002F6F690ED8CB178C33DBE6C6C241928AEBFF259B9F933A
+ C6FCE6D7372D1F937BF98CA59AE3A81CF81D6557B06B215EBA63CB3C8CF63CF6
+ 346F4CE788B6F98D145AA7C3E489085FD1BA29E6E839CD7BFDE4550959BBC679
+ 67CCB9E263FEC93EE668F13554E021C03CFC4DBB67CD428A6491B5F472DA7510
+ B8D3C378312B21700BCE49F160CD13CA937EC041ABD08D38ED071638CEBCF09C
+ 9B103CDEB9F8559AE20B2532D6138E8A2F129044E43C71828882654B3D1E18E0
+ 40520E29EFF74FACA2E0B8B1BB1909DD5F62EAA001EDECC661FDA1D0DC3AFD72
+ 145C6A487F103E0FA981CE518864069F9963FF001D427A95ABC5D3DC944D1270
+ 0D25CEE41AC957AA82B74405FD996DB38CCBF9593342DE983878F94E791019DF
+ 3847A36004ED635A061D75A1B7B0B27B262FB3F9479555D1ED7442AABB9C91E3
+ 9A29347D2F87B5095CF150BEE644C916E3DF81A2CA33B70267EAD25929EB320B
+ DF5FB418706A8733EC5EDFC54448C46DF450CE06F9FB4B138AF917A2DDEC7367
+ 0E6AE997C47A071085C6B2EFF297DFD13E2674AC699E50FBCC62033643920E6D
+ DAB14FAB89D266173856818A317F32B94B79741E5417AF9683AF2C49AE5ECCEA
+ A1B69FF943518496872B642B7BB30948CA09A60BFD09299F00DB7230E5378740
+ DDCBCBE05EF9C0A5BAE2C42C4B9D7F76D720F7EA8B96B2251EC6001EE61C7EFE
+ 9D00747AF01199B205B7F22A811CB91782AD46C26A6C536A91EFA41B7E0342D4
+ 34DCF3AC731D19B45E2A95FDA82E587E4B128D119A5CD198FA6AC8FCCF566CBF
+ 9F4C99A44EC18161A1AA0CD1750DA5196F3804D002D213D0BEF07B3CAA159145
+ B4486E22F86C28B5727F48A53160287F9DC8671466FE8A2FF8183B059B24DF89
+ 9AE1779047D0831B93B80EE5D203F92155A1BBA7D0E9F22845C8202BB45913F0
+ 459F1DFE2961146C1826F91A780F676366BBE4252891711010DFE0C9680B403B
+ A6C5D9842505A71E1DF5CB28197C4EA170023B14112D00C8C2A74734008B370E
+ 155F3A16AA8AFF586C3233635098B5D3FF2519AC4876537263F7E7CA614CC63E
+ 613B07683313ADC0DB06E405E77833B481AB1D31C5BF9DD456F3C794E4A7AADD
+ CABCB05F36B37CC673C5311ABA39BBEABC919660451EFA5EBF28E7D787B2E30E
+ F515E963344FE7340F27867398EB4ECEBB2777D2C6D8055C27155D2D09D62486
+ FB8FE9BCE37B9226F01CC86F9038819B217FFA3BA6BF99210832B0D16D0D47AE
+ 2EF5D68EBEDC77B4D8B74C75AFE347C51017A4B499F6169E19483399E0ED46D0
+ 4143649B1FECAA3E2C4DD77341DD01B714D81A843BF3C50901EE45018EB82524
+ 94E9B4231474D6BF321134500CBFAFD61C9EF4662EC5718F554C8D11C09A9C62
+ CC04DEFAE5C4C01EAF3716E215B2BE14176B88DF51281FACD7466B8FF5A40CF2
+ 928533B9E83574F10E53393B7E15641817AE118EE67A4BEFA4EC48D2E50F5CFE
+ 41F97C47870A90D74E8DE044BF9140C2067337FD92F565DFB9701762ECE0D785
+ 403EEB8AAEB4A4AA2F6AA8B1FD7503C6EED89D4716C6CC79C61C1F9B139DCBB3
+ 17BB417C65AD7BBD8A7AF092124F42E0414619DA14EF5AD3E422F3020191CAFF
+ 945B034409AB758C4839EF67655403D683375AD30B48C57A3787E42961C2F70F
+ 13DDF23C3C30F4EB36DF2A898D77F8C668FEF90AC7BABC6BEE56582B94EF941B
+ A72FBCEBBB81A516119508F1913A4DBE6FFB8A866ABB0EF3BA613C2CAC92555D
+ 4851B004032F9DAFC417D1FB0748DE3FC40BF5ADB9016F8E40815C6E74254FD0
+ 517B1DDC98370A1942BAB1AA305D12A2C3FC2E567DF6EA6564E8485D55B48BF2
+ AFC3834D5C9251761BF17FA4A247221E73456394C27337CCE1ACD8219D104B1E
+ AE4670E88D26A1EA833B984AB06104CB7EDB42736F6ABF93E81798475E38A59D
+ 1070D87CF4A2FAAFA40068FC67FBEEDC34DA58A13C44FD352DD06EE0D444B35D
+ DF250230FEDA0FE97C85C9A9515245E4D703363BF4391432C1F9986A9D5FD191
+ 2452C4527EFCD786E5499B803C6A039BA67D9C1A71EE855FA854981F7FB37A21
+ 4DFDEE4967572812BE9F1694AC1C11F442574E07D4F44EA923BC7303E13AE0F6
+ CBD75A7F5716B7EFA63390BFA23E6C99EE1ACB25DA7C0BA86330EB8DAB33D5F0
+ CDC5C9442D04803033E74D77303B562356572E4DAFEF35D15064FB8A1A81ADCD
+ CA0ED7ABB39B2BAC54DEF365F4A7058C7D5CCE2131340BFE12F10CF10EB5C639
+ 02E5D892D73BC5CE4B7A599048A61BFE634D7755645091429431307E3B0B0B4C
+ 554D15E9D0B65007E0346F6EC4CFD85A8EE3FACCE521AA0E872434B37D7FCE6F
+ 22900CBC4F482E2CB3E75F18FA18DD832C4CE90B3D9CCE1CA4D30734100019C8
+ C7CB943DFD8DFCD00766EBA934A1595A92CAE5F7AA29D392698431FDF8BAAF90
+ 2AB580B23132A518354024FBB330DD5A6D0F1EE87D94FBBF91F4B60D1C955960
+ 1C8DDA2C6C8094239EDE36BE2CB360464BE21CEB1EA298A21AEE66CD97885903
+ CD8E5AE1FBD0302D5AB749210D0B308000B6A874FA02D260992688A5002A8D73
+ F20BCD3D9CF610258EFD679860A14CE2CF3C99CC404E73BDE9A101F31217F850
+ AAA4C7852C4D3CEFB3AD3C59C721CF757865516D861D557DE2AB30F8B6ED6BC0
+ 1CAECD78448000A644E7DD07983306E5BB738EA1955D19689BC51B38E192C9EC
+ 81D34210802615F25F0D6878E1FC9F2CB726BCF7B37B687C9EF103871CAE7ACE
+ DD1F04951DE6FC6DB07E5F93625CC923B9AAB6E753B64019005D3D8A3DA5DABC
+ 0BAFACE157D0EC8645FC585B34A83DB2FA45EEBA447A12F509D113FDCED2CDD5
+ 422946FE59526DEEB46E9A65B86682C0106062973BA480B20E01A431AB899A9A
+ 0C4803A9A4AE178DB5AA63A647DBE974BCC8B16A8CDD397246AF1D2E6313CA89
+ C3C2A9AEE5C985E58FC24974F33B3EF3276420B229E1A0A62821C774995CA1A3
+ 37828CDF124A503FF4FEA2DD7CACC1BA04DBBB7FA55C916C48557DC2191067CB
+ 8F453F6D14CB75113CCE11ABF0B262B84B31ACBB7A8A9C560EF230D668652E08
+ CAB05C7A451E457D9AB02979EB049B333026419F8BB75512EE43F01808B288A5
+ B7A7744E778C4731CDB0FA7335056C5D51885F3B16E3FEBCB727E8620F02E98E
+ D3736DB0BC28967264FC822487E5C9F5F68DE4DCF6ECEBB694392A837153811F
+ 2DC72FFB6A47659087A80337A608FEA540412EE33EAF49ACD6D1CD499549F8D2
+ B798142F964BA65FD614F909F720A8063141CB183F51ED13CD559F65D5952734
+ 2A1A87E22E8E7E50C2DFB7F7F964B6F7070765689B823B43108753AD46C3D18E
+ 8823E4E99AF30642B2AAAF11C83CFADADD7F98E75082A0AA562DBC0DA5A7991C
+ 14DDAB3987AAFA127796F206C3CFEADD5058ACCEE1D0F8613803F6CC829A108D
+ 081839D79CD6D0CEF97E29AEFC600E27E5F6F58BFA864FE343E045A5B6224A8B
+ 79CAF4276575FAAA3603107F694EE28B26362A02C5BBDE009C822C9E2DDC9818
+ 39B74C40DF78C4EB968C97064C510342E7684805A5DF9D29482C8B01AB29A0A8
+ D9C1B0D92C624CC1EE00EEF9CAC254078AD34A63FC653D1858C6A5DBF4C0BA4A
+ 6C0F0884D8D75CAF13DC3D967D0F8F5246D4B6AB653BC66F91FF84D68B580260
+ 48B4CC68E260F3D41D045E8A549A7BD628A39572BF144C6E55955DC64F271794
+ C9F5C957D43824B6026DA264C97D237EA8E8021EF459CC6585F1DA0946D96AC2
+ D10D73E80E6ECBA9E44999C9162B09E73B310F49EE5A6899FB6F83D21307EA53
+ 7A328CECC6B754CDBCCEEE368FC861A1D710EBEEC33EE4911CA00B6F5F67368C
+ 09F12C6751B7A94E25ABD6DA23E1979FF2AFD1159BA544EFCC078424B355E219
+ E76B1CAA93EFDC917414E0BBA7977198203931DBF1C57C8D1770754E6E8EDE0A
+ B7C623A9C9B91498B6B10E9C58764A1CBA59FA9A8B6678E651B11919D437825D
+ E5DE7A103F0E47CDB962AA05C020AB0B71AE387ACBC5B2CD03C3BBBE7227A512
+ 69AD2DE89CA0A8CC17CD9F3E8F77CA09E01CA4209C6CE4F24A4ED2946ADD12A2
+ 83DCABF49A1BF41F6BF84AFA2CC4EF17BC5198E5E50DD894E0A35EAA4CAE024F
+ 7207C8E5712F5F03AE1819BEA1638F17435CE3D588BD516E417F317ED2182D24
+ 8D38199A62B4465D4DF3F49E90ED71B66C6FDDA19448B2196321D402A4420274
+ 309062F8CE65FDD250927B4818129D757F614EB05754BEE2E3AE63502F1F5A56
+ 79D718A759B5C69BCCE3E8571EF75957DD978A1911EE28AB92A863FE24A4CF42
+ C108836AC78E21C2CAA8F4C1090E9EAACB00295DDFFF0C51F61322A24712C082
+ 51F4A38DA410A4C3AD5C726C845E5DB95FB84E8EFF170697ED5654E530818249
+ 09BB063B25FB43186CCE5490AE99EA403CDA600B1D7F3596AA512B3F2CAF502B
+ DDF55B49021641668C5AE0E3C5E249F25679080BDB883A27A7D43935AD805444
+ 503A561F06B015680267B3E56475AEA16E88BFBA5236807500DB6DBCA644FB93
+ E594F79CC029868D2159EB315D1B406F3294A2343C5014C5672C8B73F41C370E
+ 066C78B95B63C0AC377B69FB92748BA7D4B8581A82B501E08889F5F9CF12A231
+ 1E909025E03DA5C8D75F62B520DA18A32C1EBBF65DA610299922DC6C5F65326F
+ 243ACDB6962185AC1502C3C9F9AA511F0D1B875C27C2B808540C0664FE935453
+ 6C671321EB4EF9270B248027E322ED55DA1376F1F5F2E9A73CF87FD2096074CB
+ AD2B985785F3586051508565549B53C065D6BB54CC4A94AE11CA771F20484475
+ 75284FB7D99B12A1FD151698738FD5FB3823C1DD56486C0F605BC9D11E642855
+ 57AB831C64E749865CE1A49C6BE0E670119D0174ABE040FD9CE812007978EB73
+ 344365F17A2B4CE163C95C24E9D964C276CBD2349870A35C1B467D60B1E94020
+ 1F3000385F6E1973E973D13B4443E208441ACCC67EC84DE0E68EEC54645FFD4B
+ E562062F3C7C6D19D07CB7A614EA496157409017D270AF7BEFCF92C309C39813
+ 7F38AA7950EAE7B5B66FEBFAE523CA5B535691E6E4B260FA6BB97A02A41613E2
+ AB9E7A47ABE2C7EE6CC8638E56CECFEFF4CAC4E95CBE66D9BDAE21C9F25B9740
+ AC55A3CFD721CEEDEC8B80F33B525841EFDD3C06185D2E35B9A308FECBF7DC96
+ 25EF2F8C6701CF7CDB6B19FA1859297ABDA7831DBD19710D601FE5E56AF86F72
+ BCD602999480FA9E4BA44689F849CAE84F515AB1E943FB12E6F15AAF95F69E62
+ 883789AA5D03CF9A4EEC20712F279ED77C267D6C685F2B32879E3473D1F045D6
+ 38D80DD3A9BC07C814FF00CB67AE3FA67366931E075940FA39D55E1ACA877B9E
+ 85380B2098B2EFAA5A90815DA0EB2AD3F5890915AA4220AA597C850474537E44
+ CEA9B468F666E21B2A53C6D7F0A8CF72959BE53C9FDE83C20A48308AB3C3D909
+ 0948942435DABFCB20E4850A34D61A0EF57C33C2790C0C3D348163F877651D74
+ FC92701FCE7C49CB77B12085FD2DFD4D948C3C1421A0682128593AE134A1FF2B
+ AB30A6488DB5CBD63CA927C90D8B4E866ADFBA6BA36E04CFC58ED989167A634F
+ C0517E5E05E753F96EE8BEFCD3DA985DA408C0E959AC55BDBF8E85C3655F3764
+ C21513CC8627FE44EEBA319F8C36FD0C9610A6A28B15B2FE15AD336D91BFE906
+ F3E1C054500F18676F2BC3CE9D11F20A530B20FE6F9E928504D31AF83FB05094
+ 94C74BACA1F58EFC915FC679004E9BF6B0EC95A9AB2DA7537FDD1E091A46607E
+ 9C02535D2CB1A6B8203391043FD5466A9DA016FA48ACFE93729AE809F324BF24
+ 454F1822EBF219C9E7842E6A229C0501C3FD649BD39F3084A5085005DE43707A
+ BC7A28D8E9E3BA5FBED40C7467A381A9E8819967C57A37CBBDF1137E26F03F95
+ 2B6579AC288C5A4EDD8E56A6483E548F0FD352EAA7183B4555E9B3668D89F2D8
+ 0CABD39636985A8FA3B04FE1D13CDF0B7CF60EB5BF437EAC595308746F9A0224
+ 4483AE01457F92C7E5A2645AB20D81E08EE22D9DE06F6A0DC70F20D6B4B0840F
+ 9DC5A5AC38300CDD4F08848ED3CF1EBECE7BFDB3C7C7EE619734D1EA13EE4719
+ 985455EE01291CE654AD9296A1BFD898318B57E64140DF5378373124A9760FDF
+ B774EFAD3AEEFFE4E890CF7CC3823249B264D2B7A63BDD7690ACF4B2B34C5058
+ C2012D797300794E586FF5EAC55614CCB2F076F30EB29B63E5307681347EABD7
+ B10EE82F3104B7ED0FD187353A98128FED3D653ACAF8142FEECC72A1043D0885
+ B04FA7EF75900A958B69AABDC08EAFD8C7A407DE2C149DC6ECEDFDD9B06EB7C9
+ 102896E916CFE8CF768923457961EB02447FDE9FE91547DEE970744CACEEBC6A
+ C03882305773C2FB37D143F7D4A23490BDEF6B43E134EADCC8AFD4C6EBAE8748
+ 862F0240BADF1D069785F78D8AD706B79813A4E29B0C78CCD5408CAECD89FE0A
+ 8FF2656E6ACFD97AA4403142F26690992B1CC5BAD6570852046D6B88BC91D835
+ A137D790DA3E581B8CEE078BF21B4BEC5D4F77B4C5D5E9A178139EBE70A72A2D
+ D6B0216A3F502C80DC6A180F83803634EE143C8A4D96A42D9AEF2D6F6F8A9CE8
+ C2831BD02C04FEC7B3557A99F0247CB95BB0DDED2B3D85E7F756022D3514478C
+ E446550CE6B858CA999E60F5C89639EB0490FBCC0E31D916EBDDB9478FBD5C16
+ 7B226A023A848481A13E3CF5642650059F06A808D9D9D0A7B7ECAE31D6BA4F9A
+ 01329113798B957D3EF57180845193C1417B8A59ABB11026E1CD25DB5380A0C5
+ 5741DDEE92C2A93D4F1239674E436755206433A54694ACAFBE112F078AED38A7
+ FD0822A64A70A89C83D38DC135E1AF088A2F1FE6FB9E2227BB9D2475E65DFF65
+ A44CF0E3C77F67F0B055C5F72F7F36A842BCD811FC687FA9A872BFF3030FF0E1
+ 115F368C6BA3EA532A01ADBB737B77BD489BD889EA748D7F7D83F2FF346FAC01
+ 7D5DC230B1E8E22EDC69A2D56C5B6F1C0347FA76CE7F5CA06412645BEF4A05BD
+ 0AB96E7C56E8E2CBA35F2586C1A2C903AED6363DB913D1AE8A94693F446FE3ED
+ 25697898CF9F28C31CE01E46099EEC4D59F98C3BF28D33048D2050DD9710839A
+ 53BAFE935953B2F19801C9AA642FE3D16E75A65EDD8E2DD1E331D63AB226F5CD
+ 00FF5A5DE27C6DC4707E78BD3D178B1EF4E8CCB67075AD1A66959A071BF2FEAF
+ 8AD106E37564242E8BBBB15AFBB75F71B486277871FF697946B09618E23C10D6
+ 0D2638131DB91B299A381FA6918218DE4A0D7839A8F68CAF615D85105F506687
+ F4E3C98FF1C978219ACD65972B8BC997786CCBF4E9162EBE5B6F0AD01E86D624
+ 6BBF81326EC1EFE4924B5622C3072721C1D65EF3DEFD8FEDA09B81DE9BDD1877
+ 7B5A5393B2E21621BEAE4D51C34F317EB61CA90487ACD1D9D75CAFC56C9DDF31
+ 062EE817F16BBC95D76AB4133D0CDBADFCDB8111216EDC16D1F1F14936318BF9
+ B93858B9404D272F61760FE014B7A8EA5C5C63FEE77F12703C82193A2EBDE103
+ 39EB82D4CEDA2F4057A6D94C3C8BE7BA08200DED0D5E6F44E65E7059266C9D68
+ 032ECEBDF758BB42528BC688C15122513102006BA69E4FDE55B93BAC550105C0
+ 82B9072E0B3744559C1B9BCE6E8DC2C61F911292EEFD56A7783EBDF5414DD514
+ 5806AF5C4B72812ADC0DB6D6F52EAEFBE96C6956C3B8AE465B6644CD03D8F15E
+ B56FBE9641E5F000C19B50F3EC5B0CB1AB54F13401909A61C6AE73D284CCBA5A
+ 3F098125BC4CBFABB4C91B5AE0890B620FA3E6C4CF0398AA90449B9A65F97CAA
+ D87C7DA6B6E65DEEF5BDB274ECFC407CCCBD1D3E7CA134AFAFFD2388D47C22CE
+ 24E3E474BB9F637D69CF1673B3724BF8B7D65BA0B5B0EC970B1F2EEBACCCE5C1
+ FA79A00837A8455B4EB0C48781A4CD3B7E88E250948C6659193FC86E77D95F63
+ 57676382336AE749322F0E360E35EBA5B1A3BC60716586AE9C6560CD1308AD1A
+ 3D385F3CED68CFC36343C5422DDAB950BDC76DDBE88C7710361CC0794F81779D
+ 7CF9E60EE0F713982944DF7C53143450E4D1AEC77C3EBD01F95CA56299C92479
+ D01AAEB9AD448EB04885E30AA18BF5CFDE86B34D664D7D3A17717F67CF3AED31
+ DB878739F75D4441D359F563C2EBA8062851DD4DC9565E1CBCE222F2BFB4C863
+ AE7CC5E7FA3DA0A831158659DD64B8B465628A5794FA5310E2375EB802385268
+ 6C65824780B6024249D7EB2F6C856D934F877465C3894D7B3798E628F78FBD26
+ B64C024AD9FA53C33788B854ED39B0152E648F06A12EDDF7FDF8591EB941C760
+ F5F7919B52B2DA6531044F89CC0CC07CE5D0A92A7F3A3C22E1FDF1BDAE45269E
+ 7CB5BFB9CE438A21411A1FD9B659A70B618FFD12D578407EA662C5C6C83B5F73
+ D8CEAB1722CC948E73FCB62DB7F5C1B5D38510413C9A3F69F8DE45862457C1CA
+ 899C1E3D185C5D82CF88A16D2D073C56F6A991513D85BFC0DF91FBBBA7CD3B61
+ 7BC04F5C4772F98656F9387AE5D4BB61E445D42CD428E13CBB3EF13B7E2E55D9
+ C95E1F910C98577CF6961426871DB994849F9DD9DF8509CB7B2FC3A27472E5DE
+ 04CA4298BBD0399240C99743A10D74FFE4C381BC5807AD168D83F8C2DAB2AEAC
+ 183EB72C8C0DEE46E36AD1196ABEA160846A6667FAFA4081A52E5A530C041567
+ A281B0F91DB34779A985959B4555078A6B574F706ECB1D0931ABCA8B402DF453
+ 7A70593BBB8876991D80C7D1E50C6D6C73A2E5A378E78D514FCE
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMBX12
+ %!PS-AdobeFont-1.1: CMBX12 1.0
+ %%CreationDate: 1991 Aug 20 16:34:54
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMBX12) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Bold) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMBX12 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 87 /W put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ readonly def
+ /FontBBox{-53 -251 1139 750}readonly def
+ /UniqueID 5000769 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5F0364CD5660F74BEE96790DE35AFA90CCF712
+ B1805DA88AE375A04D99598EADFC625BDC1F9C315B6CF28C9BD427F32C745C99
+ AEBE70DAAED49EA45AF94F081934AA47894A370D698ABABDA4215500B190AF26
+ 7FCFB7DDA2BC68605A4EF61ECCA3D61C684B47FFB5887A3BEDE0B4D30E8EBABF
+ 20980C23312618EB0EAF289B2924FF4A334B85D98FD68545FDADB47F991E7390
+ B10EE86A46A5AF8866C010225024D5E5862D49DEB5D8ECCB95D94283C50A363D
+ 68A49071445610F03CE3600945118A6BC0B3AA4593104E727261C68C4A47F809
+ D77E4CF27B3681F6B6F3AC498E45361BF9E01FAF5527F5E3CC790D3084674B3E
+ 26296F3E03321B5C555D2458578A89E72D3166A3C5D740B3ABB127CF420C316D
+ F957873DA04CF0DB25A73574A4DE2E4F2D5D4E8E0B430654CF7F341A1BDB3E26
+ 77C194764EAD58C585F49EF10843FE020F9FDFD9008D660DE50B9BD7A2A87299
+ BC319E66D781101BB956E30643A19B93C8967E1AE4719F300BFE5866F0D6DA5E
+ C55E171A24D3B707EFA325D47F473764E99BC8B1108D815CF2ACADFA6C4663E8
+ 30855D673CE98AB78F5F829F7FA226AB57F07B3E7D4E7CE30ED3B7EB0D3035C5
+ 148DA8D9FA34483414FDA8E3DC9E6C479E3EEE9A11A0547FC9085FA4631AD19C
+ E936E0598E3197207FA7BB6E55CFD5EF72AEC12D9A9675241C7A71316B2E148D
+ E2A1732B3627109EA446CB320EBBE2E78281CDF0890E2E72B6711335857F1E23
+ 337C75E729701E93D5BEC0630CDC7F4E957233EC09F917E5CA703C7E93841598
+ 0E73843FC6619DE017C8473A6D1B2BE5142DEBA285B98FA1CC5E64D2ADB981E6
+ 472971848451A245DDF6AA3B8225E9AC8E4630B0FF32D679EC27ACAD85C6394E
+ A6F71023B660EE883D8B676837E9EBA4E42BA8F365433A900F1DC3A9F0E88A26
+ 3318B32500F76B1038FA6122C2AF6261B025BDDECE6FB8EE33678291EE544C1C
+ F915A5FAB42D1B75A6B175895DB4F1544CA5549632E0F99C4B2F12BF8BFD0020
+ 38B512D900914DF8DD3A77CD871097AB31FC5B893699580D7DD7606A0306594C
+ 4DD48EA586002D338B883BF9D9075E6755EC0FBD60DC74796D723334A55B587C
+ C0B29F6E2E371C14E0260FB461A474557153F713CFA992722029142A199F783F
+ F9449233D00672CAA3BB85FA665B9C1DCB9B84CD30B6C87DD8FC545F033F5E23
+ 4148DA961083D1BAE44804096D4F0A5C33C62FD70CE9E68B2F50EE9E88A47CDE
+ 3340FE48E7544BC6E286AC8AE5BA6457BA1886252F5C937032EF800F70026F54
+ 6D1820610297A2EC3C684F5AA404AFD6ABB7ABEF4EA738AF48DB34024BFD0127
+ B63B83EDDF348707B55837F1F9185AC571972064669B187D3E82A92593EA680B
+ 7AC54538E2299CF9FC2E49BF5E8D88A705B89AA6826A40A9FECC811C11A2BC36
+ 2CF1C3C5DA2A5E3D19B80E6C204A84FE1A8E25EE6AC09AACACAAF0A6B264B9B2
+ 90A28CBD0DFA8DEED8C91B66A61C5E47E6E4CE73AB947909CFF44434EFDAB736
+ F7A422EDD814F26CD985ED7814A284E3738CAE0CAD6C6FB62BB2B719147E6495
+ 3FBB13E24D38DBEDF48F45640F1D9323F363355598019F256C60A27344FBFA8E
+ 8C3FA6D1242C1416AE5F2D5CCAE041954A19518662EA4A7BF1F066269FFB0962
+ C2482C139A09EEE34D488CFE4375C6542B4E0745CF5BBE727C21788606056A54
+ 320C4F8A0BEA3808BE0AF280407418739F07D629AA57E463B5A59D2E07554733
+ 5B1E7922AADA3FA2ED94BC17EC4F50A1548ED5FA74F71832AC29357C6B5021A4
+ AF2F4D49C61DC6543D96B17B62255054522CB64CC02E3A4024F16ABE3EC15142
+ 0D6D3B79E650EC60C6B39F2EA96AFCC61A37D0AF17F40372EEE9E2DA652EDAA7
+ 06229E9F8323842FBDD696AE1B4B7587213ED03BCBBA29DDF1FFA517BFB7296F
+ CFD6A4248D0951424393CCB8C916388CC763DFAEC2548F708798E3ACC2138201
+ 7EF952F282D222729E8B15ABE24D0AC3F883B6E573AC2A9A909939BCCC4C0D03
+ 02D9A958C5C547861A8EC37B9B6841C975AB6F7C497D0CD7D820BD817304BBEF
+ 0636E1E84403ED73359E821D19D48A9A0B8208945CF9A4154C8E4F3F2EC57D7E
+ B0A24D0F489A4634E06DCA9A5E578C5DF683B7885C374C8F863D4025A34E606C
+ 2F505B99C4386B35DBE34FC7CF8C66370F62CC1E7502F03AE5DDA7481225829E
+ 90943F41181201AA0A0C1884440DDC207DEBF7A85E5C81829FBFDF25B5DEA910
+ 728C787D6749AEC9A1B47AA3AD6CAAF73AD3375DFA1C24BB7A551EA433ABA4E6
+ 0FB004BE8923A3EAE66716D0411C77395C65F8181E77A969DE1C5F89D51487E3
+ F6F8F5D38925A7CBA21CEC0F397D762CEE29D9DA6A4CC76380CB01069B5FCE03
+ D62BBED1B9FB19B866C8B173E66F53C427C75B4CA2302C234921327D7C0F9138
+ D95E9ED63BC4790A178EFA6E88910A3D8E36470CF3D93E4F99CB033578381200
+ E602ED5BE263FCE5AEF59CA200907934336C58D21EED76F036C61C47A655F92A
+ B97AC850D55DC6F9994391C4E1266ADD798F07EE6BCEB44B25E4E7A40263826E
+ 14FCB7C0EE55CF62E2D8C37592898D4EE43EDCE3ACAAD6E3F6AD5CF051F89390
+ 00EA71F8D624A903EBEA0AE3952B51791E9A7700B1E5845CA63A85FBDECECF66
+ B5B0BE91FA83F1E61E103C4299FBB1AD5D4F7DDF7A9A0C9DCEA7123007F3AB02
+ A05D58246ED70DF1E196B9AAAF65AB145412528067BB74D62EF0835F8E054B18
+ BB3F585A933AE23C798B4BD75E774A203B08CF2245720973053AD371F294F154
+ 143CFA22649AA9B1A9845A27C4F7656C04D8F9D394D9801C1EFF99DA5D9A0FD1
+ 37E3EA819EBC99FCCDC33B47781A354F26F41F392B722487A25BD1C8510A211F
+ F3F33C5FDC5F3F1C2ECA443E13A70A4BA9F30D29A7F80D0CD6F7BD0FA917D198
+ 9B9DFFBF82234B4FA4960BF1B6372893FB8872461041885E31684BDE85AA0978
+ 9B736D1D0C64187AFA2B0E9179B1961EB645142845D5DC6E66DD227D030F7C5C
+ FF932DC20808711EFA243770B11778B8B11C410F9BB23D0BE188253758DA8661
+ 2245056EBB7205F2DDA307569FB1C3EDAC09578D58E1656087E78219F994364D
+ DF5A9CFB2056451E8868942E1702AC927498CFCB1B045894616C32A33567AEAC
+ 5DFC522EB616DC3A0F458B640A0AC897FE145D4038FDF83DDAEDD2A427616E25
+ 436D25F23DD88F0ECF1DAA591F0019FE6E73636ECCE0C46CABFACA89ABEAA092
+ B5298C7C608A01D4CF1EEB163C7C7AC268814E7145BD0FBE6C1E8846C00A1EC4
+ C2741759B84BDDAACAD0A7D1A0DF0A3519892EE4B530A078521CFA14A8B8E096
+ 98AE69E8A33F7E6952B199518B2CB660866F740309833455271F2ED0E17A5BF1
+ F5922CE520FA2E0F8573D9C9F2F61729556F0F509AEA3F92664CFF2D328B7710
+ 098FD9D254129ED4F57E276CB57C30479EE3B4C9F20BA1EE70AB1CD25AB74486
+ A5B03CD2A5EDCB7D01F2C2F3E2CC40F542947B4B7081366965BEF8CF09CC07F6
+ 6EFA5D6C2B59B950FD65DCB7DB5184C463B3E3AB3FD03A8C8F5CDE781C4C809E
+ 7A1CDA8E5F80EB0F98DD8A2F18F9DAA9E1874AA8E79A71493A20F857C0025ACC
+ 7B97211F771701FC869FFDA4BB8A6E7CD40A1F7E015242D73A49AC3D245A5FE4
+ 2C9997AB79469EECF45B1471B8307C18A5AF1C95F5DEFB9C0434B80DACD184C5
+ D04079BE764949138C7222C8AB2B41A5A38F6C364B687C29405859F6EA938D98
+ FE45FC80A7C54BB0CFD1DABDF570955F16B741B02382392792B270C7E72DEA12
+ 377C2DD83D65D0C63088ED950136DA656EB58096311524BC5A1A6009F66D1498
+ DAFA1F0B652FCF5F17B98BD8C8A2B5058E4EBB2E3680BAD47BA5FE7F3BB9A41D
+ 7221F84DE13332EAAD840E59B6090D237FAE74B8BC7B0C6F2B6D7E72D9257209
+ 1D1C0B76C66457A43AC68D24A1CC8E79883E3DA381B661A89E918619162BD941
+ BFF1441A49B10D87C66878EABE7ADBE83056E80513A9A71EFAFC5232D3C5D9E8
+ 5C668DBF33E5451EF5803214BFC26A85285A9DB74E795447C6DBCF25DB01007F
+ AE367BD2E45E158D37BA5C24E9F39A54ED9F0A99948B6F437B94B4C34B6A93C2
+ 427616AEB8E47EFDF5ED3F7CBB24ED0D11514991A46FC3FA667844295E85FB9D
+ A7CCCD03C4A3256C79BC49765E4BD8FDE30B461ACF344D5B0615F0B642D11370
+ 6D188BFE34E16B4C0888C20B217C0A506FDBE9CC5CA17875AE9FFA35904190A2
+ 8B97C4A4D7D92C02AFCCA4B5E677B0EB0832B890D61472FA84014CE6F4EC4557
+ A6CF4189F30BC0802C1BC54D02A35230CF7FE41FA43B30305B5FE6AD5FA5B18B
+ AC88E5BD6206C9584B3F00BD322D5336897503AEBD8C16AE296102A95BB67C0C
+ 8426652FD1E3FCDEB6AEC22F74C1F5996E1E588D71F383DAAA964CB5187A7142
+ 56CC07E2673B62BC5AB420777B518EB476EBCA0C00C465C21EA16C621D3DCA56
+ DFDA0F305449161F8B91B639259A5A849DD65D27C5589DB79753943043B3A639
+ 09D2FAF996CD20328FD057E047BCD03E1468118B277EE0BA1FF413B4E095F281
+ D48F8114A525FE7CA8F3D4689CED7EACA7677C25EC3B4F025DB790C08DDC58AF
+ 4E955E7770B8AC02935F45A19DEFE3592C7CDE03283D69E359A7105A1D0890AE
+ 3517EAB3811A618FE9BA931143AC477F7B1260DA94D766A12D9BA59E4D51F32E
+ 245D7D01ADFED1B6E83BEE18429E4C93C7E3BFA622AF6CEB26CEE3CC0639C910
+ 1A4D28DA0EC9D018974D172DA8ACFB5EF539DD460478851CB77F950E7C3D3EDD
+ BFFC3694535D350A58DB30C0BB8C52D476F62EC569EF0F428FA9DD0BA1643571
+ 46BB21EF3B4FDA6638A567BA7E6FD45DBB7363E5B89ADAE8915A2747F56B26DF
+ 74901B7E7260F1E8BC3561F80CD771D4903205AAEB7F93146C760683BEB0A491
+ CC6A4CEF7A1E328B53110E6A112C97C7894B9A51D84F0391CD0B9DDF80C1E3E3
+ 0A0EFA2148B1971A5E13C278E370784C55F3FA1C4AF65B0AA24118CFD69FD4FC
+ C70B9AFDBD4E1CBFEC07AA796CABED732878D151414687BC6221FE57791C9506
+ 66FD45ADF996745BA949DFAEAC0FA0B2D01E57D5F9615A74F9C2B5A0299CB8C8
+ DFA22EFFDB8AADC27A52A1BB548A4D46E2BE4DB70A0D394951A97D55A38C7593
+ 21658DA4E2E5A23C879E5E77447224919C16A24830460E7CEAEAFCFA335E49FF
+ B53FF369C54903890AAA11824B7842DB45B9D72597725C940C38F891D7D8096F
+ 80B4F3651655425708F996601526BF6AD8C34B9BE4C01C52ACD032D558E9F544
+ C5CE75C8FD121CC7B19683E3F39F674890D297EC663EE69596E4E7A5E93299DE
+ 5AE3E872AD74BF7C24BAAB0E01F6E5D01EB43EA2FB7D005C8A597A5377FACA31
+ 7C20C6AB27C3EA2F1C9C4535F7A7BCB418D3FE87816845B2DEF7B7CDA0B1C9B6
+ 75BCB030A5EAC254356EADEA7F2DCFD92594EFD3C2238E2B8FCC9F213E5E5F1B
+ DCB5BAFAA1944443286DFF26782601887E6589260494F64ADD73F5BB701B4641
+ 60908D8F0CA530975CBFF957BDF49EACDE4C1987D52620FA08A0F1AC1BFB74D2
+ 4048F83773FC5E85135AAD852081C8729DE4EFC2D2F758CD2D650D28A2A2E907
+ 7D3EC05360B7080E8934EDFEE8DE364479E096336FB3372AA058EEFEB8BD9A37
+ 3E224935130F661ACCC10EA9826D1EE44FC7ADB218C239F4F89C484FD795236D
+ 18875F40CBCAA5F7A754184A17B61CA93D0CA48D84B086BB38F0E0099925B52A
+ E92E6479314A29415508E40536C90D4FE8FB8329CEC05A5C5DE1B8DD4B56D647
+ 9251E53CDF718E82CD3D036FB587AD1687545CCD7A7B69F75EE06EE6B28B58F5
+ 2A25CB37AB44D7ED94463C7547E7BF4A3E981F4336D0A88B3D1F76C3E8EE9286
+ B22848BAA8BA7C62C9FE8203394E05A9C215D662EB6CB04FB146AFECA0573F05
+ 39C8EFB6270B904F4DEAF71E9A3308DAC44089A964FB26E79195D8B0FBFB8CF0
+ CD55B7FE813E2C2B056F46EDE34C4811880E667EF94F1E1764314DEB2D9DF272
+ 393E4A54392F0B778FEA92C1FB29B1B5F83E68B1EFEC7912593ED213155AA00B
+ 32A099E8513A6BED676DFE506684D0D453620EAF0695C3BE5229F7A227BD21D0
+ 6719D19831A8DE5ED6D0CD839F463B0F43C9A06A41F8C745EA6BD6969A719EDE
+ 276D8F0EFF44B86E353BCC662A479E465EEC3B5707E8D1DE765C28394ECC0EE1
+ D674EA89A627FD0EEFFF59580F5A9002E066CD9C1F1891CA16B5A5979DCD9C28
+ B8808F95E931F33CC937BF72D060D01D2F695ABDACA98F982E306A91C2B1EBF0
+ 0D5C1937953055151CA53C703D26C618CEDF0758D03770333D31DC13ADD0C7CE
+ AD6ABD74CE6BC95D82A4D17B073DC0F00F9853BB0A46A70A0172AA75B75520F5
+ D97BB6B45D20688E0EDA2BB7AC5A580ED106FFAB9E32DCE48130CAE3CF8F363D
+ 3BCF40F029EB68D2D204206F000D237CEA83FA71F174BF78978FBEDD82DEC1C5
+ 5CAE775C06320AB02261CE3E9C962A46A4BEDF87B357F7347372A4F0E6D8D3C8
+ DEE221B9F63BBC1434E8B1EE857C6DAF38C4971689620B3621AE8500598B1B6B
+ 33C2417F368739E529566D2CF3B1CC61A8013F16F17251361D4A0891312A3921
+ 319C63893B9CBE620945E61BCB11FF39FF5DFB7542A220488AC3D274D43F1416
+ B9DF38C33AEC8AF90EA58FFE72704EF69E1EE5845FF9B9847C4669C74AFEA6EC
+ 1FE5C52C589E532F562EC73C4497F070DFFC1CA48147B17B012BA84228D475FC
+ D6D3C9A6029CB54207013D714E202599442FB98D6DCAA764978E5D4C34483DA4
+ EAB4D50E8D3545C5587F55D933ACC4655CE192FF2C2C770E844F09FC5EF4CE5D
+ AA22F67AA042971765311D688C46D8BF41D83F624644108B895C7EBB9D213992
+ BAF456BC8EFF64C8AA7B689A43B318D0E4D418D8DC8216F9C15A597C4958D7AE
+ E7A349705BBFE56A29F15CB4D4B6093A2DA10486549A6B83BE5FEB5C263B0512
+ E008769D43F365C57621AA60180331DB5A1616641B5BB01674E47E41AB716FB5
+ 967DDE10A0F6FFA5AFDAE8BE9CD711F6F30DB8A8FB6484CE7DB6088199FDD4B0
+ 0EA12FA59C5637D806B2828D48F7593F84918D7A102DC5D8116F44BCC8262A30
+ 03B1991DF7499D3A221DFF1B4A664905F799E2CFA94146C6694903D348699696
+ 99F3EBE3E252C27AA37924688BC326A585D1D3840BCB861A2B7BE444DF9E26E1
+ 0BE9012C03CA3CE015E16039C4437123E01E4140E1AD898E4E3A92D9D5534ABB
+ 62F0893F5282C78226DD3F06640B287C6CEE136B381CCB9FCC9558B1C1B4C648
+ 1B0B664831249257CA833E9150906E90EEB20543B95307C6222E34B32A53FA8D
+ EFBF2F07A604E359DB6727E5386915AACB0598D68E24C047F68699A75994FDF1
+ 9DDA09182B98E535231C37CD91CF9FC2866ED688BFA112C7BE78D51D5D43002F
+ 0D0EE0DF0782ABDA289891E57C6DF4E04C8B4B0E33DB285A463C5676A75BC96D
+ CCF87CA3A10C1478622A5E8F62BEEF8A49C55293C39461DA760B909607DE5B85
+ 446266D6995E07AEE04D0C78F4B528C544F574688CBDA88022B0A0A3A3E47668
+ 624372E4F7095FE06DE55DB7FCF36C3670C23385699B269CF96B9587C9389DFB
+ 0E84AE666B0E47785EB9FE10AF98E33A590FA2AB35B326AC303E008A91541BC6
+ DB08EEECF379DA33A505ADA3B395A632304521CB0EEC764103311FB69B569166
+ 1940ADB889B3426D51715DED9D9E8763082617290C5836BF5C92C3729A1D115E
+ DDE2DCAA14838E6A9A5EC8EF445CD77F0E6C0A16F3A523677B5C43EDDC9128A6
+ 76C6F7947EE90289D0FCAD431387A9C49CF7AE7D9798DFE45A8EA4969284B378
+ 2449E230ACE0B18EC6DBED9A7C62AE2A86D55C322D3A66BFC7069CB5E968A88F
+ D22F96156E1FF4CFF0468C610948B49445B0D933614D58CD88AF8C47D0C0D475
+ 82735491517835A10D29CB6B1F314BF0415FE6718D5645814C7CA73B825B3B64
+ 2FF79BAF0CD8B6DB6409583ADC9CA4B1D27FA1B375795583A458B802E73B11F0
+ 9D4CB661DC12BC48404E6648BABE0F71396DC2E76686C4982122C15612F1A351
+ 4C031CD5A99D8E3CA419D167431E72FCC61255B4B03576BE3823E98CF4927FEA
+ AA6FD360DDB930990C12B186AE4F7E7C87F912AD401AD2460E3542FA4C07EFD0
+ 9F1537732BA8E495B8CE8FFDF2A5A1E455FAF243D04F408CF46C6FA1B69B76CE
+ CF0E6526E40CA1B8AC05032EC97ACA5206C70F89E9705F42D9A6EEE35123D331
+ A331A4EF7FB30AFED5AA8D2657156561FD690AA777470C2FFC23005CEE8B400E
+ 86A82F79D87F3212A7150168ED97EC5338F3D0964C5C16535E359BF53296D3C5
+ D810A9906BC249D4E93250893508920C662934F61BDF16B5EF3E182680AB737D
+ 4A725185F6CF62E9E1660A5A816CEBEBA0D549895604F057497CD6BBFAB11E16
+ EE6790D00B0E2D5605E055F6BE7668CB1F52FD7D8BF06DECAC9C078EB71B15EE
+ A4B45890A4264DB206EE0F7C0EA6A4D07853568A27B406B7E6614966B4E49A06
+ 1581221898E08A00FC416C317676A44982FAE50546279E93E58274A0EC4B4567
+ 0B7561F11BBB3A19A87C272F2DF54F0B7CA41DAE4BE6975324ED3BC7EB254E98
+ E23329569F8FFE57AE9A38D79381162318B05178B5ACAFEB284D54D3409002A2
+ A695A875665AA82E09B4A6BF5FBA03CE5D0CE2091099D68D5ACA1D7B02FB0AA5
+ 0E42832FC9A7AA53420F3AE4D6B6B7D1AF5536A7E5A54879199495E810E2818D
+ CE255488A7765DAF9BBE75C3D34431D8714525515ACF99807002EDF3CC522A54
+ 831E9E2E5D9F1240A9D0F4082C348765657CFC2775862CD88D8EB684C862F09F
+ 8DDFA997D075B463B051BE2ABF2F5FC8E72182D6DA83013780538B7E5CA744DB
+ A811ED6011DC9EF5A9400B0F1BB53D423F3BFFA0BE8A9E936C382AC7A04790FD
+ 0D0735DA17A1289FC45F9AA2258D77AEC99F06CDA78F7FF9162FE42D3519928D
+ CABE8AE52D78509E386741D535C35617EF8DBB4663F8243ABBED70DB446CBD33
+ A816C209EF4A6349D8BCCDD04F7F4B174DA3120CEB27346BD9196AA8D6E37B42
+ 90C113506B4558698045BC5AD3B5FBEA0F8D786C66B5DCE939E7766B594FF027
+ 281F8E013A79019D31FC2EC1FBFC83F5073CC4258FABC53D1247C1491AF5BFFE
+ F0A1D9E2D693BB0E748C2B021ED8058FDF962699C8BC3D5565174D8D8729310D
+ 57DF538E9EAA056AC40E6F1F88BB24768797376B93808D25D0587B168B30B348
+ 5745FBB4BC8C86C597BE3E5EAD84D23A47A81C3E608EDFD83D5DD7D62E5FB42C
+ 94165C9C4D89B35C09D3DFF3FF45C527A07D86D3920BE77A3B3CF4665DE678A6
+ 2250943384D1E5306997517F56DBACDDF90E47E9D72690745ED53227583F9078
+ 2BC16E692F464209782E0E086762068FE61847C37C4D550C294561F217D94236
+ E26BF2EFE880A803425074A35CC5525927FD8BEACA079FF2EACACE9394332549
+ C533CFFDEE8931756438D8C962D0C7C5C53B2423993E593FAB3B9362CA90B3FB
+ 7F79E9D4DC1C18C9CDD30CB3F78F7C4D52BE042049EC1DFFB9D8F8396B0EAB68
+ F4BAA7D8B1AAF68DEDF22321BFA8CAEC405BE8F8B70F08707CC34DB6C383D5D1
+ DD0E902DD8DD3293EEC874E21FDFC2A9312ED571662F8D02ECD5B98BAA90F957
+ F0788549E98B8110A9CC8EA508F3155D171944716C5477ADE0FB415E623A06AB
+ 76484AEF8BCD56E3E6EABDE73D874B05AAE91803EACE060FAE75AE1E9AE96BCD
+ C7FB55AA09A97E18FEF39C859A514B24F17C006865F7540B9B42D7709769DDEF
+ EC6F2588C3B3831A9CBA0E6D1A9ECB306181B977985B9F551058D23F484B48A7
+ D27C8C981051D276C2206B7B48D67133A4BDFC629C545814BC456EB867A334B7
+ 4CA4CBAF494E173C6DAFFEC87030A7F136BB74DC666E8E37FA78CE55E3C02260
+ B9A22520C1B43D92E117C67C5A6304988C1A058DBFA6AE423E89BF57E930B82F
+ A996F933B762625EFE6E12F622CAC7A3821FB7B337270661B3FBF9BDC6036E94
+ 54C7381B9857280008490739C9F47E897702F7491029EF5F1E8132A79309BE8E
+ 4AB1C98C63CF2B9D1CF0379D4CAD7EF9C84184B95B83D584ED5511D3DD1D3E26
+ B488643F406A95431B9DED95480D8263FD4B98B527565F32021E4A413FC64841
+ 7FECEF51874297D3CF67F47CD5A18F7959BDE34FFB0B424BA9D1220230DC5A39
+ 04DA4DB9E6BBAAA5BE387F96D0569E96540BEDB18D05C0FD0E3A4DD4F7AC4E3A
+ 9213EBC9A594F322360305C16D6342F943BC05617AED50C7B7DE0A4274BC4ED7
+ 2066F253690F5A80AC2DFFEEFF312B0B6114CE76D0369C6F98114D27D492D1AF
+ 2F86E32DD00244F529DE959FD42A562C6D6EBADC5459F5607200E611A2C3C352
+ CB7A7FFBCF4346E2CBE37FDCAE96BB37F3462C726EEAF6272320FC771547F6C4
+ A2485FE243A5C447DFA7CB25FD9ADEEDE669FA19B6A9E09C2473641DAB0067FB
+ 82E00D929374932BFB85558CFD78F8248DF98D9711019EA8A75A5D899C834544
+ A19122A0A14EEE147BA768DFDF57D506DF4E9DC3FE6B9ACDBAEF7238DF9FD14B
+ 4F4D6810481944411A423F075450EBAF3AD81A1BF5D1BA59374CC0E2760930BF
+ 926416BAD1250F48ABE486B29B8C6C78C4BA22655F5EEA9B3FCDC8B19ED28182
+ 5F6DDC6E19CF9482C931338903F5DEA07ED7CE96640376BE3B0C0E7CC15309B8
+ 27C8F1891EFF6F91722DEBE38E68C1C74BC2D66EB8001D6CF225C06C352BF471
+ E1E3AD6B8194D7F47B5DF58C4B2676B21C70FB2E4C835EBB0BC718AEA9AFC97C
+ D3C01C7C4C6AC0994443FB6A5CB661CF5948E9DD64C3A86B04A0CC68C6AA168B
+ 1551E0933E2D2595BCF025CA98FD87AC43F306081C3BE69E6A94AC2F3B820334
+ 08B67B3DFD39E88D96EDB58F50585AC9FA24949F794483AD43060A20F5220E69
+ 24699E2DD07EDFEA3DD14DCE9ED3CF9C8144828AE6337CEDF0A470B92A256D4C
+ 53E4B6B2F1E4F76417D3E263F973E7A24881C1D8C7E3BE0E8C05DB31D05CF317
+ 2E4CCD9FDD4F6C8B4D4D32CB035A891CFBA292707C530A3E1A40BE713F618C2D
+ 6372B5AF3D48AECA4B3FA35B9EB23BFA10AAF88CB62E897A3D036AC25F4978D9
+ 5624FA3BAD6566FD745907C983B521D6DB9BC5DB2DB51C72258430F22F5AB38F
+ 020411767B964593444D7DA2CDE99D30A7DBE7B44B6E5DFC568ADC89A6CD7524
+ 2AA37D24DA859428F080817B679C41AB1298436AF86A2860455A6822F3A81FEC
+ B123246AB77F6D178686882880737777FB9D043FDF2702B78345C254B2D07EBF
+ 281043F1B6BF55F18233FA47321552D7985746D93528A3EFE97214B08BE0DD52
+ D494B10BC2A503C75459E023191E4F59DBE7039BDFA078A65D3D337846FF483C
+ ABE40ECBD98FFCD778F107233CE6D53733E4E1D00E4B8E9EFAA120092C70412C
+ B239E671D73821823242CA5CD4E7587DB8E568174C17884AD4D90635C5124AC5
+ 4F15D50E324F9F3484109E1BBC463E272AD0D4648127F480EB32F91E0A02FEEF
+ D81A050E604EF43B0CFEA89EC9F690B2CB9B673529445B2C8A0FB965CCC3B4D4
+ AAC7D4379ADCF6A80261E523F5107E0E4EBE3E59432064E7A1DE7C671596092E
+ 4488EA2722959CB68976F213CC544B5A49862E300202E7E2EC1EFA333777A78F
+ 742ADAF5AD2B46E2C1923689F15E3F719D895959CBDE9DA08E231C0786F0BA00
+ ECE1796950D60FB15673853A6F918102AE6F55F03A4D1EE39C14B9DB5F672954
+ 711A749AB27DB73D57B012491D5DF87E53B68543FC64B251CB207DA014C43EF7
+ A97C416C649A359ADCB015DFE028221B7622F5685E0490C27DF50C2DCCE3C711
+ E8B6D395F14FB631733AA30B67BAA79EA7D9BD145A9F50A4798BBC990AE804C8
+ 17291388D1C9CE36748A6E8124229FDD9D6C6984F1F91CE9A9E6BF2FA8498435
+ BDFBC39CE48F6FBFA5F767BEF47DEC27CBF3321DBD6AB5053BC4DF71A432CA0A
+ 3E293E5FC48C2D8F216771C060D4537327C9F1D02D3A729B83C30E6AA3AA9DBD
+ FFF69E707C1641F5C92BE49F890C301BFDD46A18F11F263B9DF2D3BFCDA12748
+ 087DEB1D3CABF6B2C628C9616E6CF682CB1D97B0624DE0DB94C30C138138584B
+ B172F55FED3C622E0B512D846CDB6E41ACA61885F4534A1FED4BC69FE5322BBF
+ AC37CC7DA741F5EDBA032EA074EE09521CFE573D2D929BD629E4A414924C1102
+ 609B4A56B9F87E35A363E14DE497CD19B936AE4439BD111C32AD148AAA3D9883
+ C9873CA3A77D48E2BD225DF6C94BACD0E85C5BBF8203EDEC3034B5BBDC25CAA0
+ 43BC750DB83355D5D9A8577623602EAF8C2574C49EAA0B306396DB4CDC1BA5
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMR6
+ %!PS-AdobeFont-1.1: CMR6 1.0
+ %%CreationDate: 1991 Aug 20 16:39:02
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMR6) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMR6 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ readonly def
+ /FontBBox{-20 -250 1193 750}readonly def
+ /UniqueID 5000789 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5CF4E9D2405B169CD5365D6ECED5D768D66D6C
+ 68618B8C482B341F8CA38E9BB9BAFCFAAD9C2F3FD033B62690986ED43D9C9361
+ 3645B82392D5CAE11A7CB49D7E2E82DCD485CBA17D1AFFF95F4224CF7ECEE45C
+ BFB7C8C77C22A01C345078D28D3ECBF804CDC2FE5025FA0D05CCC5EFC0C4F87E
+ CBED13DDDF8F34E404F471C6DD2E43331D73E89BBC71E7BF889F6293793FEF5A
+ C9DD3792F032E37A364C70914843F7AA314413D022AE3238730B420A7E9D0CF5
+ D0E24F501451F9CDECE10AF7E14FF15C4F12F3FCA47DD9CD3C7AEA8D1551017D
+ 23131C09ED104C052054520268A4FA3C6338BA6CF14C3DE3BAF2EA35296EE3D8
+ D6496277E11DFF6076FE64C8A8C3419FA774473D63223FFA41CBAE609C3D976B
+ 93DFB4079ADC7C4EF07303F93808DDA9F651F61BCCF79555059A44CBAF84A711
+ 6D98083CEF58230D54AD486C74C4A257FC703ACF918219D0A597A5F680B606E4
+ EF94ADF8BF91A5096A806DB64EC96636A98397D22A74932EB7346A9C4B5EE953
+ CB3C80AA634BFC28AA938C704BDA8DC4D13551CCFE2B2784BE8BF54502EBA9AF
+ D49B79237B9C56310550BC30E9108BB06EAC755D6AA4E688EFE2A0AAB17F20FE
+ 00CD0BFF1B9CB6BDA0FA3A29A3117388B6686657A150CE6421FD5D420F4F7FB5
+ B0DAA1BA19D638676E9CF159AC7325EF17B9F74E082BEF75E10A31C7011C0FFA
+ 99B797CE549B5C45238DD0FADD6B99D233AC69282DF0D91EA2DBD08CE0083904
+ A6D968D5AE3BD159D01BDFF42D16111BC0A517C66B43972080D9DD4F3B9AE7FB
+ 11B035CE715C1218B2D779761D8D7E9DEBE277531BD58F313EBD27E33BEF9DC5
+ 50C7821A8BBC3B9FDF899D7EAA0B94493B97AFEAC503EB5ED7A7AB6CCCC950AF
+ F6A29F479A2D64381EEF89EDD5FF966AA99B99DE93538FF55E471CDE2C53B4E4
+ 8903A6741A6C277220A711308EAF916E9829A6C937C0E3EE676D84A59E0FEF72
+ DDE9BBB1579659EF8988185220D6953F25C02AE4707C1856107110A587E6F46A
+ 2BF2E59A28254562F1C04C35AEC4F3666AAD6D5D6C2F3A071E654CCEC0CDD428
+ 763CFAD39EDA6DC4EFA0472B017A94119FB133E4AB53E3D45E0B8EDA6828D47E
+ 53928387245E87634F6A4865A3D760B7B9060CD93B1472537B47974E542F9C49
+ 896E151C2420537814F3434DAB0582EF056B74F9880F595A4AB22E6FAF249C65
+ 3CDBD6ACCD1AC9EBC0481FBEF8FFA93EC91FE4F596CE965313A67F98FB3023B6
+ 0CA44339C09F556CD71502716F7637788E4CF07031F7441C62C15D74AC329E23
+ DD146F03FC4E3118B1613C124FAA5A3F8261E3371C7CBD093C429543DAF125AD
+ A5F14F0DD1F46036C0A4FC58C189B7FABDE2DE545F40EAEF2E33A6C4CD73D949
+ 17566D1719BF8224DDB8D75E39E1238A015F2563A343D8C64F1C51B24E3F713F
+ 218747C7CB071C9573E288FF3FDBDAEDC4C9B7B32E3CE9C6C04ADC4E8033DE06
+ 6FD5C8E6F062C5ACC0DAAA0C847EE2865DB0C0A3F814044F621C6D7B6860DE33
+ 95BD34AC406B647490DA2C4305B089F704E7DA7994FC07554355D8A5C0776A2F
+ 84B03682DBC452889661CCFB440231B891ADF363321F31E4EEE48068BE32DDA3
+ 7C52BCB1043E4C554737A7510D4CCDF451B613D285FE4D1E3782BCF0BDFBFC4D
+ E93931041D5A6CC0C6C50BC705167157A8D7A79367CE8616B44CBAA422B17353
+ F56AC781B1AE892205523A6BE32E5785EC2C9CB032227868CDD6D58FAD44B7E9
+ 23FD68F302BDF595C1AC77B204AAA56D14988995C27345A74E3A3EDB9AC13234
+ 662E5E44C80AD126439079D7FB957FD8A934C6FC839DEF0831B9763ABC8DA9F1
+ DE90DCBA227E5F435539A7D6ABB78C7E0DD3EE937F6CB74A5EDE51EB3FA13183
+ 2758ED7EEC4E5F23AF7267F4C653A8925473E21546FD9F1C2B64154D45C4A714
+ 730891934E276069E41A38F4349A89D60A9C5182CD944B22DB0CF74B15B18702
+ D841A3FDBF7381F18C757DB834B60C280499DECA0590A7FEC6A5FA0A7C12CE89
+ 99BABBE1119C278A088B4EDAD926557970BA229042F97C6E638C7F31E04C6889
+ 2DB9B835CA4CE5DFAC1E4B64461E89915437C4366C793A2393E9EF14A048BC51
+ 25DD67CF9258669CA4DF79F24FBBB67FB59C5ED113911E6C9D785EFA3F81BF40
+ 0EEA52148EBC7E8775AF44E8C1D89EF1BCD85F65C03C5774D656850F55F93C8A
+ B7E5F766A1F4688CA8D3C43DFA8282F505E93C6E5EB470EFFFDF506790056E4E
+ A188ECCD402C527D1AD3AED91CBFF5C795D31E2097CA45C499F054A412FD6B50
+ 091F145BCC4D9227D54B6A8A3550D7DE7039175690134EFEE68B4240B420635C
+ CB6CD496DA562233BD3E51EC94DAAB83DFBC932F5E67A80C5A359C2A144108F2
+ 8238056AABADEDF56F2B659FF3DCD47748AB4EACECC36EF5FDBE87CE04B2AA37
+ AB214A822F8FF69327426BEB8E3CE07495F93D65A5ED5BCCE15C112AB99AC22E
+ F64F92F342D5BA56F9607D2DD8BAFB38F85F48C516F6B8EF81474F2E4699B2E9
+ E622998DD4C60381EDAB6FC6CE0FFA11D96375CA64F1E5328F4D13
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMMI9
+ %!PS-AdobeFont-1.1: CMMI9 1.100
+ %%CreationDate: 1996 Jul 23 07:53:55
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.100) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMMI9) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.04 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMMI9 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 14 /delta put
+ dup 21 /lambda put
+ dup 30 /phi put
+ dup 58 /period put
+ dup 60 /less put
+ dup 62 /greater put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 71 /G put
+ dup 73 /I put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 86 /V put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ readonly def
+ /FontBBox{-29 -250 1075 750}readonly def
+ /UniqueID 5087384 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D5993DFC0930297866E1CD0A319B6B1FD958
+ 9E394A533A081C36D6F5CA5FED4F9AC9ADE41E04F9FC52E758C9F45A92BED935
+ 86F9CFDB57732045913A6422AD4206418610C81D882EE493DE9523CC1BFE1505
+ DD1390B19BC1947A01B93BC668BE9B2A0E69A968554239B88C00AF9FBDF09CCD
+ 67D3B2094C11A04762FE8CC1E91D020A28B3C122D24BEAACF82313F4604F2FEF
+ 6E176D730A879BE45DD0D4996EF0247AEB1CA0AB08FF374D99F06D47B36F9554
+ FAD9A2D3CE451B7791C3709D8A1DDDEFBD840C1B42AB824D5A0DFF0E0F15B0B7
+ 22AEEB877FF489581DA6FA8DA64944555101EB16F7AB0B717E148B7B98D8DBFD
+ 730C52937E226545CF8DC3E07C5BA30739BAFCD0F2B44275A6D503F582C0FB4F
+ 449963D0AD2FAFDE33BA3D77BCA9D1DF878DDAFCA2E22CC4BACD542B282164C7
+ 97C2BDE318AF9D501CA21F6E662E7AAB75A5F24D2C182E598D175D44E88AB19A
+ E7CD59584F95B389183EE21B525BF52A3F23C0FE5383A5565A19361D716F508C
+ AAB78411CA5A4D27552CC1C435760D5A89D535B71C593E755C616661363308DA
+ A683F54ED0C23FB2C225A008392B0B719F66F11A946A090B7C00B662A3C69599
+ B4ECB0CC70C85C4BBBF207E0026F6C7A19F2ACFB7A60804FC98A4BFFD7BFFF2B
+ 952B42CE273B1118F73E1809D2911924A418CC45E20D9A9C026201263F4A1527
+ 48E376774D7C218132B4D3680590AB2AA2C2EA741D7E96C49F4BA3E705E2D68A
+ D288EC56011CD158D02216881B7E45314D94E45D7ECA73776BA42DACC41248A4
+ D19B97FA93D40079BACFE26853F0DF9F75201C59C77FAD42905A1B39ABECBAB2
+ C0925759BF0900E0E011E8ADFAD5859FC718F307C85933D6F9FA42D823683703
+ 8BF34F6666AE5C90B42A4BC5F2F4B170B4DD23DF5C5B2A5D955D48570DA58601
+ 91048AD24E8CE518DCA74757E4EA963E7163ECE811D1EDD9120E9C40C3694D1B
+ FDE07C899AB4CC88C39599F405049232F5BD4C7B2B4697503E5351F38DAE0043
+ D91CACF055FB01F22B912A9CA4F68CFB4D2A93066DFAD3F99720081B3FFFD621
+ 47369BECC7277729483FBAF319375AD3D5765180E9D5B23345EE6B9A1F510EAF
+ 5DAE94EEC977BE193444174AE3EC0724DC2ECA308B8ACE7E97AD72CA13599CF8
+ B0AE11E4B087897900B04A13E2989E69176E6427E453DA237316B4FA3F43D712
+ D0089A0D7C402B8155B53115397262F11CC7C3F67282ADDCA76BE8EFC1EB9389
+ 63ACA7B3D43E894C6890D154334D75453B3AF447FF60F3E3235BF6F471CE16E6
+ B83B4EA1A788E9EA287BC5FCDF15728F1B80B8CE33FAC8E4522AC8B977DD6C28
+ 1BE1E1A1FAC123080347F6AB2B3A4ACFAEEE0B898B921CF4CBB30ECD00DCF854
+ D1704A29CFF27067F79AE4FF8D428B732242EBD813E2A3B4B9453D8AF0C58AC6
+ 0C00054EBF904E1E66460361B960CDA15B6F023B24B78DB5688B6C6E61616FCF
+ 9E87ACB3E99C95F4B2F4F10F6E6C4BADF70421FABBE1A118E037BEF657E47986
+ 8A4F1C3117CDBF8DFFEAF21B65FA1B2F47C41BA5A76A239ACF6071D6969A92CB
+ 7F5B9705D6F78A7397988B464583E8BBB465B6DCD69ECC712D79FB27BACDB6CE
+ A9E7E971F2CECF422106F64C31E9076B9E6088BAEC3EFDF91BCCE630B12D2DF3
+ 16CD215640E1B47A16A8F055653ACD8E5E38EF59E9B4A0797D1997E9CA59779C
+ 1C87EF14079F796FCCAC3CA6BBC3A2F8EEEC8310AEBE1194E469D8D08D61E720
+ CF9CB834B46D40EA524A3D12365EA831BFEC3200520FA46A2F61DA75170AE5D8
+ 60122490C07E3CAC55F4B498A66099AD23967E7FB2D9A6A8DA3F2E665D06C86B
+ E67D8848F4557D086AD43B0FF2DCDDA93550B0D4D445DBB37F11C4240737543F
+ 260894896F3CB096F56F2AC77C42F946AD6CB66D5F114160B8DF7DA48997EDAF
+ 5750F8B2161717B30590F82E2E7F11268DF8C95FCEA4C256414DBD3AE42B64F1
+ AD6D4737B347CB53CEC5DFC3B1F3DFC6B8346E28370B091F513AB781E423604E
+ D5CF3169A6E70E9BB84495B8F5F76CD448642F382DC005A3D8346DB5C3A60247
+ F8E8F6D8E9D8E55860A696290883B271B108C1833CC2A18B2B88760722A407FB
+ 47AFF5A756A47D717BDDCCE99F5F76C2F96444307778E7E3C25E86BA1037D8A2
+ D3F78651D6D79C28A23E6A1E328E6354CB25D89B823C25D4A4C622536AD7C19F
+ 8BCB6BD03CA38789D6A590B2BF294DBD1CD9ECF0C67ED3591D63DCFC464DD55C
+ 057E8A30C1D2237C9361E725D53C51E99BC951FC383739A16AE870FDAE484E49
+ 3279EF84F5C5063CD77B7FB5D807930C6099491C97E26C91D5A86143619B9CCB
+ 44D7F24241D5D9DF8B9F5EEEC32D4E8FEC38F501319F96F58D63392B480E3854
+ 13A9DC88F1AD3016CE1345C49A3ECAAA60DAD560C81BE39012CE72ACA5C87C29
+ A36447BEACA3D5735435F4D51C79D8A8F3E71F0AD7F1766817F5F66B63C370D6
+ 4B68AABD3F05C3FC530B93DFA5A7DD976758BAE61726EEBF9A4E81D4A63AE239
+ F3FC37E0F9D430518A02390784FEB788B5A87A04F0AF52A659D11F896359FDA7
+ 50F56D27549B88D17542ECDA4E60B04363095BD03EE3A2C4C1885EF1EED6BB5D
+ 2CB120BF7A61E2114E02AE32FE43B610F132AD8DA55D702A07E39FF8BC69A264
+ 53730FE3DD65354948DBEA082882729EA46B8CBA9824D19994A858AFFAFB1FF5
+ FD4A8A50BE84DCBC29470AEB643C0F50BA067E2276053AAE1934E475AF5155A4
+ 0E4EF07260A617DDECE97D13DC109EB29EA1EE0BFF1A536E36F937A3C8653BB7
+ B99C7FE17FAFB9BE6619044F71A64BE9AF48BD50AF5A0179CAE7747E45707C45
+ A07D87A699CBD8CC494EC8365508DBC13B694C3E193A0E2F5B0652CA79D4B739
+ 8C578D3F5E76E187C5CCB509D53783F6E909522A5A051F620F9AD728FA8D5713
+ 2BDDF99A69952087E8214850B75CADED1631DF267C3934E6E9B1BF82E72912BD
+ CA251088CD46F73FBF547723819B8B687723404F2749435B52309DB14C13561A
+ A0A5ECF105DCF37CE7042A71B5B6A5D306BA252424DA782C0E92D39C05645A7D
+ 00EB9A20250EACCF86E6F64CF8F22571DCD60EA3C88A8C8683A703CC6747E035
+ B259324CA81BF383C1706BA9BDDFC6C1AB1D72E87FE7E4B33E9BBE6D87CD06D3
+ ADEEF9E5FA0175A81C70CBB2157894F9F0624DAB2BECD5DF97BBF6B21F7C9564
+ B31BE0BDC1307E72D8D18C30AA12D57841722BB4989965C0D6DF9C6AD52CE372
+ C08D8ADDDCB0655FAF3179DC92A837176092865467166DC93E601E827361960C
+ CABD1F85D8BA708D57C1F6263EA246885AD4F38D2228FAC7BAFBBBCE8E67649E
+ 42659BB1CCDBC2E1A64C768F47E5B1CFA6E1947CB46715E6DB262FD5A2C06999
+ CAE71C3CE00371BA7DA6BDC2F03140757EC16211DEC08D53F3449EACA952F26B
+ 94D2DFBAFFB6600A0BAB4AEBA4DFF606E1A61196ECB5B0E1B91AB78C52E365D5
+ 6013DE360C9ABC6FCAE2D6BDA5271E206081F8B5FBE27767F0BE1FBD85409CD7
+ 90A7C48C87EED7227EA81CD16568C0D4AB41D2906EF4086480ABBCF679F845D0
+ C1F8607FBD039869A25B0E548D035BE33721800CA09A70E7828118BCB7EA07D2
+ D723D114C129ABAFF1EA6F9DB2B764953E35613A36D0162CA33A50D6859BC44E
+ 28116F4863AF2A1D003227740AB0CE2F54AA4BCC4D6ED27E79842F21B7EE0860
+ 20E95D9CF28CD0D38660B4FBAE32F717294706E8A966D4D0B3001E3F090F1708
+ B9DB7AF1C07EC3FC83FDECC80BD0936F8AB6D016E61D8461FDB8EA2A7BED5246
+ 58E47BA0F394FC4A41FB1EEAE8B014B0FDEB98E5E526ED90F1D791574D0E3600
+ 46D7F94D692555E22CCF1663D76477C6112D8BBF39D2058A047A43030DFC411A
+ BBEC2DAFDFA343053F6B61BBA9F1A13F6F50416ECCB8B5CA14BF400F4949E646
+ 54A1537F22219166C70A4F83F37B9F55E449FCB1F76BFA968319E66163B8D34D
+ 24DF395F39BBBD566F70B2D6D60CD529FD1CC0E4C16FB717AC6FBB7B0A6F28EE
+ BAAE77B130AB28A304D2E7472E2BB6745CA3D8F17782823B364E5B05FC33D85E
+ FBB880BD8300FA56AFD9A8B1A31221597B7E8604CFFA625F34D953C4B78A7DFC
+ 379D41B91425D34ABBD0ADC59F40260DFF119F54254DF94349D444633E754705
+ 9F35903DD6E809548300CAE56791465491A915B115C9A14EF2DDE3F4E95E1CFF
+ 9D889A1C4FD4A4D11E5F53540FCDAC7629D8F2C7DFD6DBF1E39209B294F176EF
+ 306EDF1F4AE1ECC026A4FE3BBCEBF56CB55A17607A77474CB55F14220A945862
+ DCE7A79FC292A6EC5AC08AC627C46D6533C07877425683291C61AC8850733D1B
+ AB5C1FAFCE9AED16A235C8A18DDAB7F9F0675778EC9E9F77CF0A02A9F46EBE80
+ 4DB8165766D7B69BA634A95A3BF119455AB08E1CF43E1EB9776A78D591F83223
+ 6935E8C5B09BC4AC9C0E57BF80CBC5073490B205B7F6F117FE122A00BE38F663
+ 9FF2CA4E00AC6914CCEFE27440CFCCB2D32EF4F4C37FA0E6E314F0F574393FD2
+ 658C6ADE010C5C9411B13477A6B4E8AE2ADA7CCAD035F48F039500343D5D7F7F
+ 9E04D863941FBEAF4001934C35195654A5450CF0291050C60BDB5AEAB77F1E12
+ CFC494C0B30C49D1E68F6DAE8E02896227A57B878333420FD112521FB45B6BA1
+ 262AEF6910D65D01ECB1FE94678CEE890444F3073E6E6E18A13A71E533590B90
+ 4B7E6F1FD3B1E0764BA2C17C54741374D2DA9A51AEA99102657ADA4899FE0535
+ 510A45CE6DAE1C3EF36D6B687F911271F6124BE7EE38EE5DEC03916EBE55D3DD
+ DD15225D26211E49E36014F4AA8F2B51703BA407C9ED55734FEEE21ADA499998
+ 588B98B987728A1AAA179409AAB498204D29BD4DB4ED367331B8F1103C8773D7
+ 0ABEB1FA1F331CC3B3E74DC95488F282FF62CEA062FF094C467505CEC1C567AA
+ ADE16772195058D5ED47354A9AFE06FD0E2EE528C983A75371175BEA7C5477D2
+ 168D28114A1284D60CAB158C524F86F82135F4FF5F0E2E46D61B6F6C74258E94
+ 7562B0829BD048E5BBC6876E06E4B9DFD1726556FA9916456FAFBD155B5C7E07
+ F1D7DF5C8F3D7FAD05EDF7BE67BDF01665E8F73A7F3034D327E1F57E39149E6D
+ 4A0088914FE9F8DA8B1C666E0D504BE312101C5C781BBE4E27433B723483E9BC
+ 81C00F6BC8080CAAB6D27B7D5BCB63556C497F1D3A01B1E07BF4B0874AB4F612
+ DA9037B21AB083E2CAA7CE031B771703C57C7F2636988F3BB131CC231B16C38E
+ 96413B8E5A6F1A8C05CA69ACD991CE4236E32689CC6BB26E8E301790A7CDE3C4
+ 901A46C44649CD88162811DF572BF6D46F57724B1B159FFF461F20EC23FAEECB
+ A83CEDDEEA4670AA091AB69C4BC4DFC50A2529C0A507F7F2338120100F8FE621
+ 572B5CFD4F8AADA206C09CEEB30B46921F67E1CD49B13EE609C96A1F4AAA8C68
+ 320373A5C5E93657A56B06D4A400C374894F773717D5C991A54188D11C8458F1
+ E8BA3BFAF4594156A0D2CB5E6F2C73EB9D04CEE518F6356BE82E23913DAB5402
+ 97CE347FB0A6E29A51629FF12CFDB367302F2D6F00838A6A418DC6502555B119
+ A663D8BBA5587134C82BC2BE493280421273CAC4DB6679F2529AA929E7A06A3A
+ 8F715F284443A32B41153CE958272960D40BA0578F16725A84CCDFCB94568FFC
+ B4C3A8566E8DD69FE0775618072AC77D7BCBF973D2CCBF2404C45FFAEFF792A7
+ A14BBFEFC2DB34D89F4893C4B9101A4F22BF4E2970375F3B9C65271DDEB5716A
+ A949B1F4D2DF693A075E8DF8578FC399C833F8A9627035DA5BA9DC1E6FBBFCE9
+ 35E858D68018CEC6522E76CEE4CE969A1E2CC1C3940B8C9D96CBF0C22DBD21D3
+ 4356053427B46092DDA944D609486A8033E2EE4E34C97435185D38BBE1A5682C
+ 80D8D51ACF5AADD079ADAD76D45734BEB29C04041AFFBA99E420ED9FCEA055D6
+ 83F689E5327C7A9AA49BD9B1ED7ED72B93F6013AB78985FFD5F1CAF992F5002A
+ 68183C52019C750E7CBDFAF4E9BD30AA5B908DD24F3CDA0810B10279F4675649
+ 2B666217C8192F08B279995D53983F98C70EC8A2372636E8BC05548B41743D4A
+ 7F4ACE00EC7CA0095A35861E14D1D98AC3AFD7D603813DD505E481D475691A41
+ C2DEA85D204F52FA868A677AB80982F72C0E0191EE626F5EC8B73AF62A0D0C8E
+ 4141AD03E727CBB0F26E8A13B7930300239884F1ACD8113BCD6AAB97831DDE46
+ 8820B1DA863CDAFF8F2682F9E3253226539F9CC1D8C96B556A47885BCAF6E1A9
+ 9D9BAA19CB5901778A892F4F17308FD3D1506DA9227BA31BA77C7C6A73002463
+ 5F388558DEDF12D19846B90A29F4ADA920DB547401B6A76E3D906EC71335D472
+ 55FDD9A7121F6AFFF91ABC0E063EAA757E6D8C772F6AA0BA2CA1821C93E7A7D0
+ 28B6B7EB4CBA415CCF2903F6356C3E8FF5FF3C8C6546364B5EBF37B3E31CE91E
+ C55E139089F8D307704C6AAF8E45EFE1FE2FFCF4B5878C9E73C1081ED59FBE21
+ 56B7B7A263DA5A3520AC214C33FD7F0C7992E8903414F870FE331AF1FE32F30E
+ 63670D3B0955406EC6FB7536D99D338F9458907900204FECE700D27AE17A4E26
+ 77E31B4DC2C2DDE6A5FB388A3BE37A21C4ED820A33B26317A8697D2A5654A1F4
+ F2B7FFDDF94D0812F86F0356AF0E2D91B25D6B6B984AEBC1D37AAA72B3686359
+ B78CDD39CA05DEB76CF09A47252E5652A1BD1EB6826A907AF1F297C587454D65
+ E6C2BE1D656691A1E3277C97BB526A0972F1478D25AFDB5EB0B3F63DB520C2AC
+ 618BCB55EDB44CF57EAA364D92130CEB8B488B6D31C37445FB18B6B585D8ED97
+ 5C25ABB575797076A6EF3638A811121789BA6195B9731E462AB184AEB6A3B7BE
+ 493D12277A6BB990E7B397B1B68EAEFB5FD87CF1F7C593E6C9BB054F26F86E84
+ 2A3D80D80673145138265DC0117E21AC1B5723BCA5651DA1A41CC8E5FFE237D9
+ 1CDA6C28B306910C99FA138981495239DB74894E564EDA4B53886CA55CC97DD3
+ 3A754AF3A6181A6D9AE23D36E78B7D8F554C9BA6546B23C22E1A955F9476179A
+ 175F9CEC9714FB97EF26D8B8F1633CA575FE0F164FC105C5946DFB7EF2E7DC59
+ 2906ED6D05EEABAD5413A87AD34877C91D779296B7320E40F174D717CC6376B2
+ 5A1C4AA286371BC74F06E18870FE5BCABEC9FCA8160047A21D186253DF342949
+ 783284A27D7BE9C719EF04A5C9EAB0FF9C3B2008AF144C028A0B688BA4E47412
+ 30BB81B28351DCFE34E6263667963B79A5045E2234EDF91A75130EC4C44BB721
+ 54898DACED7A786FCC089185390653105D54E9B2B5FF86CC2F3A9B9CC13E0BE0
+ DCEF502DAF7DD21C1F6375C8FB6F02C5411E746B8D8B1943C0D7A1D4920E5AA5
+ 793D8DA05D0510BD0696D5042383CF7345FFF37EBA5438FCBFDB283B7A4B70D0
+ 46886A78A4AA73807C41FB975136958D236DC36B30DABB08EB8BC48C4B03B7D0
+ A6FF4919342066E2E7DB96B1A71CD140CD9391CA3094FDC5B2114240E2BDF08D
+ C332720F59D07814F84361A00A809D366C6253F9459440D62A131057A01DB7F5
+ 520FB89134E43202C8064BB99E487B6700FFF00269EF282737444E4FA85BA95D
+ 334C0670A18BA14844AEE31F7BAD9E7553D792756037354848497181D4DB7D22
+ 3EE963B53E5AC88C3A8B4F215DBC83CDF0B595029DDD40A5B361D5A5DB687971
+ D606D1E98738E46D20CA2526DFABB67AA1AF3194AC642B4E455FD62F12674A09
+ 253B747A01FCADE1AEB96E01B9F040E48FAE213F0E15C205FD4C204D0EB56DC6
+ 3049A5E87B94B45B59C99F2D28FEA4EB381C6A80A56F7072351BF0D3D0810B3F
+ 56B9D1F1342F52249C026AE6BB184A6458E308B0CC5CE5E42AB3EE9F9A970ED1
+ 5043FEEF5A3678AB372D3823F774D729630878E9636AAFCA8E6491502CEA345D
+ ECAEE961EF6A9054B5DBB5BA154A1424732C3A29B5C30BF6D2E43CC020465FFB
+ 67CA656A0FA2E4F196D22D25762011E61BAC9A088C6B2F2804286C60A5C9E23F
+ E6C7C392151F0BC09806B56401DE8BBB9D0036234EAB30C375BE9321B9101AD3
+ CC0CBCAC3DA6ADC7937DAD4D4DE253786796E56020F9D8218E608145606BE9D1
+ 0E39AE3C7B9C8CE69EEAF7CEA2A980FE0334BFFD559FF7CDAC0376D43B61CDEC
+ 08561292A6DD4D3C12668B67C23676D51C407416B97CC88DB8D5168DFF4A67A0
+ 3163B10E38E4D7843F27F0B406F0DE6601D93565B5C22046873AE0632A311BA9
+ 39A546C2A432965E4035394E43781CFF58EAC805E25D42706A829B444792106A
+ FD5991FE455E18D7C126BD0DEC4F17AAEF4A5132125E8AF28E4C507DB292D099
+ 1DB16D9FA53FEC3269282CAD188B475C5F6AF4D0261E32ED26006D3637F358A6
+ 92FF18673B7EE6EC347A092B810E572A2B8095AE276BA45560BC7F5993E210EB
+ C7DE29FCEB9C6EE251CEF94237004090234797109A8A6CAF2E4D6B737855FAEC
+ 9B80BDD2CC9B8A181437526B18A0EDD86A65A11B847CA6319D0D500D19620C1B
+ 3FB1B73BDDB4F5078835C2D513EB26D8C389AF1669F3104A7FDE2533BC82E85B
+ 00B2E1A5FC3CE312928CEF41A66CCDE49F26D06C6A770E89A9B73C6FC9BAF7E8
+ 5C5B13BAE060C4BE379F5958E52852EEB9E9C1C4EF1AF25193ED52750820A99E
+ B446E2676025D37102F0EB10BD4DB5493B29519EDAAB158E324134FF8C25EBAD
+ B4635AE08286D6D780A9D02717F4BA0092968E513755F9B2AAE0A16757307A6B
+ DD7EF57F43717D78F4B55E2F9BDE164D965E1EBE7E536907C6BDEE634013D6DA
+ C5D3DBD6767CA96DC73331434E785084971889AAB9E0F272F0501953610E2289
+ 568D44547C9F99E5DB012364A5D6CBB1A9FFF59EF623F51056B49498471F24D1
+ 53716654213740A9C0F8A7CAF9C0CC2E8FD861A7F5100F4582FEB3D4F96F17C8
+ DBD3DD6859064D7BA5DD2903CA5C55DC4CF4C890550ACC4C7AD6791D12BF396F
+ 22C155716B491B6FEA2F361F88DA62CF848A716DE8F62204C8F0AE134607E7FF
+ 2E6CC1D32DEDAD4B4691CD9C7545E28FBBCFB891E260E7B59F94B7A9B813A2C1
+ 13C477CB303C03A832B3260F9110BD374A06D442792CD998584D3D7D3D3AAE61
+ 4C8DE177C80C1AD974A6D28C68627A21F7BC74A5B002C945A0AF067EADDFD4D6
+ C1B2EBCEC4E32422A6ED0C55F3E172D7AB40C47DFCA68CD9CDB8C83754D22FEF
+ 1460393D25ADD24C03DD6102064A2F0B68406DCC039650094EB4B987DA7AAD10
+ A875614ED4964DA971A0BE76830D6895C8269B8CC8F4AC32C087B11D57D74684
+ F88CEB7274F775990559C01C818CD4A65D5803200586663D4FC637E3847C22DD
+ 2181C723F801947815EE47B374DBE9AF8897B8D5DDAB166FE76E1A8FED23AFF2
+ 80D286E56458AF132947B9DFF4264DA0EA8FE6C90AFB7F0481A152155B466638
+ 48CA050DD43D8376681A6FE457C36C617CC1DFEEEA117391E33634B84F961921
+ 84E7576F4E893523BD7BCD005ABA925BB1DA4963E0D753956A000E7D423A09D0
+ 4D10AE3BA446065E0452476DE6DB3AC5ED2BEED83A1DDCC555622FAC44EEB5B2
+ 97334D814351A8032E8079E3A86C3168A29E3FFBAF263FF2FD272650739BCFA3
+ 4B475461A7579FAB8F0F1ACB858CEA999FFFDC94951EA79630EC6DD56909638E
+ 2B5E72B26F6903503471BEF119C04D937A43047842404D4C5465C3A5594EFEEC
+ 9F03EA9A6C8425EC4A3E58E52F09F41F67B94C1F4CE4F7DFCB8CFA73FB2AEC5B
+ 6B1ED7E29F1413C65C0E7CC6866C5C26DC789BC037F2D2E197BC14069969B779
+ DA1EEDF8D4CBFDA266C8970E42189ED7EA1259776494C79F8C2E4C9A06325504
+ 906970C074B0BD9D9488B30A25A4B27141B4B61CC130BB9F223A8EEE0FC4AC26
+ 09F11FC55BAA5687D27F8DAB22156269D2F09ECA00756CD18F7630B1330AD004
+ 8750EED86EB809EE37365CD63E07F19B9941AB4B3EE0BBCD849F8D42118512D7
+ 3218DE7E09BCB6EAA4D0136F5AF471E190374657A6B58B1E7808B51E6E3B6C3D
+ 322B673515D9799761BC39158FA6F72062879F66D91EAEFEBEC600F9989609B3
+ 73A9C440173D20A50502AD7F65690A322D3BF7E01388C75532B7386D165E960C
+ 1EE62CA27371DD9C0C761E090E1B59DE8A3927EF64FB8246D85215C55E43BCF9
+ 15F7F283C52B2961E1F39F9E1CA1BAB1D87F95D6CB6C30538D76367791FE0489
+ F9D103CDD178ABD57A766486EA934922F0942A0AD8844F9A44B66C70D5D780DC
+ 9A86C2FEA51968295E93408D68973F1A001E3109F0299CC6126F449C18B382FD
+ 9D600B0775BE4701590B4A69F97D26004F3D4AEF297B73761C157B8BB55104E7
+ 6E57D66E759A45B3E19430CC85975053251EEF1F99D5DD725E3CB4C9D6FF90D6
+ 132A501AC86D4CCD50CCF1B61D07D709AC857D7BB9FC754F54211B220E94F3D1
+ 07FB07660A7221AD4C966DF01C2869ADDECCD1F76F28D8BF929155FB051FE277
+ 284BAF682F3531FCD6E15C047E698832F0CA0EA8BE0519FA2625C328B4EDBAC7
+ 798777144CE6EC06B72FE236E359FE83437A2E51BF342FE606E3E290B9B4E432
+ B0CF38DA654929BCD19066D3FCD9C2F6E3E7B310B63FD7CF00A915B1C6494CD4
+ 89FC8BD0EA52462A2B422E2F3C9B26C4986924677B0494E436EF4D32F023DA24
+ 21EF6160BABF80CE34926DE369917CBB7B3105AC35705C002341D2D5B7CB2AED
+ 81DCB17973CD2BF10F0584552478C1F95A766077D7ACF70FFFCFC25A762FCD35
+ 728AE5B3FC229C407166F2EFB0DC542C86A1B0FB4E556C9D744D370CD1BD8A1C
+ 0FDFD59B656C7A7611ADE8982B1A5F2D922CA0D001394B672D13C7E1E3A7D1D6
+ A27D8DE51E7AAD0894F3BD1C903AD19B0AB4DFE90DAD8D241CFA563F18935D08
+ 490A8AE0997C10EF7CEB2D40BBF6AB3CBAB04DECBAFB00AFB6FF7A86B0AFE621
+ 273FAFD243F43B4C909E77472BBF9AC69047D4A0093F4220780D4AC4F0E6F098
+ 85B03A18179BF482E6F44157CBA3E6972C60C2A896700D6101E89112C3D6060B
+ A1ED6A16AFD2FD7765FB2117E3AE0E3C2251036926B23AD5F76229AA71B5489B
+ B8B967A296AD1377556825FD7B71DB9FA93DA009689C15F2BAD10C4D5F4FBBB5
+ DE693719C3FB5A2BEF346730DFF55168BDAA0215285D4FBF048F254ED1890B11
+ A1677891CBF8F047515FA6068BE56BF62C95772FB678FC8D715269615DD9D395
+ 83F44D49A2DD1A1AC4ACE8FDF3911F7D98492EA20AA71E0F88885AFBC8190B24
+ A294BFD1E122FBECB342D9791C12530F1F4E09DC4091F2495D6E13F005402D69
+ 44451A49D83FFA03743ADA0D2BA00A93A56F3FA5F7EBF1E5B9299674ECE5295A
+ 1DB4A8D7189A8A0F17B209FFD14D583A72D118C1300689582DA15D8C5F369E48
+ F94FE0934C3D19B601C2CE7336F97578024CBC65F8201E3796516B1347123E5E
+ 49965AEB2B1C2D0979B2CFE9D5B645B3CB7188F1D72F2ADE881581E8627C0598
+ 9EBF5D64346CF238487178AD4C19D81FB58E25289A50D11E8087CBD37AA2408E
+ C90145202448305BD8F928AF1BFE7AF2C1D4382E881B6E94D12A357B8FA7FDB2
+ 6E0C315E452877D7CD9FCC61C3F77FEB73DF20727A29DE42294C3C710E4B3A9E
+ 184799C4B2DEE3AAC03AE99D648A01BE946928DF3C8B30ADC55CEE55CD374123
+ 83B3C86A794466ACECFB9D4825ABDB25356279D2325F5010CFC0D0D04B626708
+ CA4FC2201B8B590909C112D0D9AB820D0796FF7BBBB2D4D3E8632E1A935F476C
+ 6E3DAB66C4C593E56A3C9F37605CF47EDED2B89E01120FC6DDC3136D02582A55
+ ACAF165E11911850F4B614E59E5D164874DD525115A794136DEACE8A5607BE19
+ 22739542B6035FE6E3E1C8D20C29A116C107AA3D75DA3902C2A82B178B6CD381
+ 973E4D033767EEF85605BB14C0ECB4AE1256B2D0B046C8DE7ABEC0870C64FDC1
+ 3BE7E20AAFA9AF37E98C37AAC686F4E4E0F597B6AF8D23657E95CBCD47713620
+ 4819943F9DAEDF8C6C3AD4839E2CF2F59CC9EA6CD0F1975E48C5EBAFCB7B1134
+ DDA539B478F25D13C50D53CFACA1214568390A2BDF99F4FEC1A1222C3A32C2AB
+ E1EAFA8C677877A072E233A33373363AFB7F4DE2C1FFD51F555F2BD185DB28CF
+ E71210C037EDA970FF9C6FAF9B1DF55F57A6A79622C7628A38A635746638B299
+ 0DF16570F0873142A0DC8143291070A0D4649A9554D289E398CB71F442409623
+ F362CEC25B647FF8CDB92E96D68B2AAC43734E9838D15EAD8C9414B1DC20E65D
+ 9B8FEA91863EC83CFAC0558BD8422E911D1C4458CD8D8A4B4209F6556976702C
+ 1270A8525EC4AE77FBA31D278532EB6D522274C4677A6EBB9FABCEA53AAB0B31
+ 78000B1C38AED8016E6D359D363A8DC8D979759AE0B1097342F91774144D476A
+ 3438FAB45997A055C3D146F928343D3A508431AE55F11541A331FD5F044DC870
+ 78BF1136669A05B087546AA6284506265A0BDC60826A7DC6C4951CF46644E732
+ 07EE83D5FB1CC2D115D29A171374FC2DA8E2F59943FA61A9785FD39BF8F5A207
+ 7AD2907575576E849558790FBDD16BC12272028C4CEA0CE4E0B05BB8E1373E5C
+ A6B1EA829E80A6522C58976E36FA7CD59A256FFD2E0B9CF4C7D080CC58651765
+ 8456EA14321E9B4E6F13B4CEA0946CAE8B3482B9CAA5DE2470AAC5F738DC30CF
+ 1D1C57B0333F061E781F845839DDCAC288B71EB8DA3E1EAED2623BDA58D431F6
+ 5F43DAA345EC1E06101AFCB95DD4AF76DE015BE9B3D2BD0E7D05B37F39A5EF29
+ 1BA3197C892932691CB100DF6A79C333C16837094A52A7223A4F99FC1DBD0E73
+ 8142E2854D920372A57E48A8ADE50A93DEE707AB366BD14D0DBCECB3025E2574
+ 627983D826F76F3286AE4E31DB11CC835E179C982B2C907D8C4CD1642DF75803
+ DDA0AD6F7BBC74EA3D59922AF2EF911415A2605EC61CAF4F558D4BC5DDBEC9AB
+ 6F45CAC04AA2D6A846854BD40A7363AF1FD2AD2ADC345DA2B0370628D9FECC91
+ B7246CF61B6A1DD44F5DE699E404C7ECEDEA672F33914976B71713A3F8508730
+ 47BEE073605E19D1903BB5882E3F33ABFD3CC274F44E0239873417E50C39AD25
+ 3C155674B831ECBEEFA7B8466D598A5001ED8B1FDE7503E4944D8ED70024835A
+ DF92D5FFF452A180AF22396CD4B7A02C38BE8030607308DD89800CBF19C38345
+ F2C490ACF71DABC5782549DA6597065A1A57B1C7B08850B81EF057CE656B3AAC
+ 859959179BFB44646F6F2318EA020D1657A06045DE60DA8650BA204A7AA83E96
+ 3A0A6E50B8C831F2D83C06A70233CB9C93506E93FEB3C9B9276CF4A4879BDA1A
+ D79D94F9AD6427320923C92708F2F7A8725F687D50E8DA4AFDFCB468A19B5E0E
+ E89066287641EF5F146D6DAF8BA9B8B7C79413AC6E91AD58CDB2A25A8CE77963
+ CA4C2DFEF137B363F78598ABA5FFAE48D29448224D470889D2A8D57B19BA715D
+ EA7756EDDB0F417FC90D4788B72775D5C1871B9CE6C7FA011A25299E4DB2F126
+ 731DDC3B038FFA33A3EC173730C053B5A3BD35D611ABC496E36ADBADDE57AC78
+ A741A935DD45285B3C5422751BDE8394E44C4501C7205E37996FF55EE0E76796
+ BBD36E602E8268087C06DC85AB02F3924BD2AAE9F7EC21C8FFCED1E0849EC693
+ 72CD39022144137296F25F31301B96FD2013E1362ACECFEE37C56C81F9FB5E37
+ 39B4FD0A845DC044502B091BDC0F38A6C8497B778BA0918F536C078528BA5F9C
+ 65C130BF04B860BCD2963080A54128EA032F6C47932DBA08B967D380D5DB334B
+ 262B14160C4AC1D305837D56A80C391994FE9A898849793C56F3BEC029B6FF4D
+ 740E0B91590DB2815DDC40E9F351989D78C010D5451FB516D041BAFC5114BA5A
+ 9139F78C7BBF010E319C2E6AFCB95A3906
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMSY9
+ %!PS-AdobeFont-1.1: CMSY9 1.0
+ %%CreationDate: 1991 Aug 15 07:22:27
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMSY9) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.035 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMSY9 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 0 /minus put
+ dup 3 /asteriskmath put
+ dup 50 /element put
+ dup 51 /owner put
+ dup 54 /negationslash put
+ dup 56 /universal put
+ dup 58 /logicalnot put
+ dup 59 /emptyset put
+ dup 91 /union put
+ dup 92 /intersection put
+ dup 102 /braceleft put
+ dup 103 /braceright put
+ dup 106 /bar put
+ readonly def
+ /FontBBox{-30 -958 1146 777}readonly def
+ /UniqueID 5000819 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052F09F9C8ADE9D907C058B87E9B6964
+ 7D53359E51216774A4EAA1E2B58EC3176BD1184A633B951372B4198D4E8C5EF4
+ A213ACB58AA0A658908035BF2ED8531779838A960DFE2B27EA49C37156989C85
+ E21B3ABF72E39A89232CD9F4237FC80C9E64E8425AA3BEF7DED60B122A52922A
+ 221A37D9A807DD01161779DDE7D31FF2B87F97C73D63EECDDA4C49501773468A
+ 27D1663E0B62F461F6E40A5D6676D0037D33F24E2FAC2B0009AD3C8350CDF8CC
+ 65BCA87979C36D14CB552E9A985E48BE4E88ECA16DF418749AF04FDD2B0E1380
+ D281BB2476BB45FF30946B247DFD7F57305FA87E50CA338121C71CDFDF927A9C
+ 77FF14CB4A1D6D80356FB1171ED38C37702350497B44E42CE31DB2F493807DAA
+ 15B887C671199A54C4C1294BC520F5538C15556BC43C9F62342B121C6DCD6C5F
+ 491DA47FF360201EE21C08A781ED0589A6DF91B99FE118B9B29E4F068672E52F
+ 1A06C514D91C4C937D4E642503392B1CD1BDEA5DCAE1267AFDC3E93796BCAD88
+ E05E54927AC165AE7D5964D8E2688F4605DC76356948D67A39DB7AE83EFAB826
+ E58A074B03C8E54C343F6B6A57E05D5B751A9BFF4863CE7A7D3CA344FA072CAF
+ 2FEABAB99CC8D58CE1E5C03647382B074FD875C93FC8C1BBC7A7031857B73638
+ 52091403784942CE1520C4CBF9B0FD7BE7B4D0309E751D3D536DAA2F296794EF
+ 0E71D8E9284A7600F862031DC4A59772BDBFFAEB6F7288031FC1793B6A6577A4
+ 69A9E2B5ED51A3D2169B72F38490E1B74CC86A05046B9679D7F8BB02D84A9788
+ 56EBA2E1F1D9D3685EA16B220D7F99FDE51B51A438C8FC6D24AD152ADBEC13A3
+ 8EA9A0618FB168E8195DB2317EAB506F68A1FC33D75E290065682E750E73A6A4
+ 7064F7054222E5E3F6E2145F07C4B8B1E0705D96B308DA2C929411AB7D74F5EA
+ 8B81DE163AB0EB5C1F1A6B0145B725EAD49B677AC5A5FBEFD677DA5B311E77EB
+ 6A156A976879CAADBCD04A61C4741702B83D3949F01EAD4255721081CFB1C0E4
+ C34C388ACCD154494AA869DAD3061FA0840548B0821487C81E9009D982475219
+ F5C47A8949F10018995D41004D35E5F98B992A05E1EBB4129876F3A065ECB1EC
+ 5B6318F4E3EB794DA546EE59B78E1171CC4D1A7EC88800087540FC82C38CA29D
+ EA0D115BAC87EA2004FCE7828289CAC0F8AD52CA5879D882330CF3A4285192C4
+ 916A14A5984DA2051C4201FDB4DEA50048DC9D4BA60AD387E21F6EDC4AFDF553
+ 5CDC18F68AABF128F3691BCF22BDBA8B595FD947A4CFA53E6CD24921663EDE5D
+ 7F318779BD9734B7E7319B0AE93FAD55BDEDFC3F501DE40EFFF7B0CE3ED909DF
+ E6D1E0AEF19B4AE6AE5DFEFF8E5C1DCA141CAD394B483E8F0126EF87F546A649
+ 4B89EA75493ECAD23DE3536B3A1D60E13BC23FD0FFD92A0AA34F1E412CE1C831
+ 0E0F3C78F1F6F99ABCA949910B31EEC9E133493884E450D99CCACF7E387466C7
+ C7D120B177BBD565551DE35ADFE83675FEF5EF4B50FED8F5C742049026FA8107
+ 95EA5209DE5D950AECCCE1AEC665957C1A6C37A0232AD5EF3818454DF8D3921D
+ 3D487DF11723196AF8D97A9B2DF379CE5645FECA955A4F119B047CCED335F127
+ C4F67EB991D6211B1A2FA8F9270D902DBAF8B5228F93F9467B26A09EFA1100CD
+ 0931E59BF8286D64A693607B88194880364ADFBC2C455C6C28255BDC18C1FC89
+ BD906C96525B74D3F667412E6AEEFDF110B28C8C215D3C1DB60E4924D7DAB2D1
+ 25EA5E2B5B4BAE3822DF6B7B62CBC1D5556148E2AB8079A729D665CC37C9C7D5
+ C1E7AE349125C3429A9EB505711BC343FDFB664068D027BE85329B11FDD06D50
+ 67DD5D11833F667C58B0F2C5A761A1E7AEFF825F3191D5DE735206B5D977CB47
+ FF1D01C5897A50AF3DF2769F0FA9B6BC73BCDF99E8579CF4F7273B64B18D4F18
+ DC1389E0432172E5B00B275EE0F2400E75E7673CC358291C74D809579BAB42BA
+ B2BF9566E5B635F685B8943C71940ABAD9647CF49D9BFE3BB45CCA9CC0893081
+ 8684EA3E9F52EC44BBF0EC0A455B6CA30B6CE8BD9C75BD35A1FF8F1BDC66A834
+ CCDEA9C6EA5E9ED405930ADE7D37120BBA274F4167130B03FD66BBA994EF768F
+ A3ABAA67F66793BB70A7C3941216B6E129AE48E5BE0E8AD927B476E0AF60778A
+ 1E58D235C178437B3D29825C14C95DDD6BE48FC3FE6B5FD55BFDC3CAF30273C1
+ 89F1547BC88BC343F0552212E4C7D1A78B524ECD3A9950CA34251E86AAB592CE
+ A514660D31E365EAD5C6DFEC55DAE037EEA8630F8AECF5F68CFD7FA2E9D10D4B
+ 2038EE1C1FE0CE24D372FA769E6E7F66F453CBB13EA52908176FEC284EB06961
+ 0A24A6B2D832CFDB6CF89BDF7861153A4A120601DA9DB0AAD3E148CD80ECC4F1
+ D1B4E84D8F6BE8DD240E5E66DC29956598B57B61E83C13D4F6CCD6EB019EB915
+ 9C6055B58FCB985BFC217F6B2689A65B73B23AE1196987D9A3232802A6D994F6
+ 5FBFE1EFDC645CB9027642EEFEE039AE329228DE8F9D1A4BB1C72F00B7B149A1
+ 8E0DA38C54B593A8756D062393E11568456270A238957D7B0F924B1F6F514298
+ 8399C9C891AF91086037488D60651295412FB87EA68A0CA9D92E682E412AD945
+ 811C9F18CC0AADEFAC5DAAF0E35C0C3ACDA7C9CFAAB73BE0758463E596B46ABA
+ 6EF2D5D626D0E25F62D23C3CD584220A4FEC1BDCEF3497DC129E3BC107848336
+ 0101E8CA02AE8679D7ADE9949C0E56D698FF6110588B3C541CA82EF3CAF537B3
+ B81B96BF2E8ABC15C7EA916D7E06128E064397B889659F27938D09B3DAFE1729
+ 9BA2B4E3FF228A6668E5574D82DA7F83AC73FEBDB65C84BEFB4416A0F9BC4720
+ 910B8D0064A50CDC1D87D2AA5E3470E1B3ED43B0298AB68DD1B6A8038A1BD9C8
+ F37945DB03B04C07884C851B554ABFD3D905DD6F6F70DC4B5D8A286A96A4D95C
+ 21AD20F6021DB977BF9ADDAD0C9A9E8CBF9A74ADA86F9EC8CB68B8A07C0D8453
+ 4A1744AA5D65A69367F6D4C6A0DD0B2401A36DEA6C397A7A7E0202F35D0F54BA
+ 30CD4E2AE41C0B86CE4080FFA79C5CB6F5980E26BAF96A4EF5814A485DF84CFB
+ FEB21E042FE354CB28D5D3D8049DFCD6F77AA08DBB7670775E2E8A0952A67D34
+ 0F304F85D628814D95B715C48108E95420A969739A91F7BC292D39BCFEB28A9B
+ F7EBA5D8360F1A171C7414C4CC40DA23EF7BB836B392317664FED9C45C6584B6
+ FE92AF10D7A318DFEC6B19954141331BD81DB953122C5795F0FF8EBC5346A8FC
+ 4565A01DF1966133A057776862C28337F2FF1DC9DE27
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMR8
+ %!PS-AdobeFont-1.1: CMR8 1.0
+ %%CreationDate: 1991 Aug 20 16:39:40
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMR8) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMR8 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 34 /quotedblright put
+ dup 35 /numbersign put
+ dup 37 /percent put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 43 /plus put
+ dup 44 /comma put
+ dup 46 /period put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 59 /semicolon put
+ dup 61 /equal put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 91 /bracketleft put
+ dup 93 /bracketright put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 120 /x put
+ dup 121 /y put
+ readonly def
+ /FontBBox{-36 -250 1070 750}readonly def
+ /UniqueID 5000791 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5CF4E9D2405B169CD5365D6ECED5D768D66D6C
+ 68618B8C482B341F8CA38E9BB9BAFCFAAD9C2F3FD033B62690986ED43D9C9361
+ 3645B82392D5CAE11A7CB49D7E2E82DCD485CBA1772CE422BB1D7283AD675B65
+ 48A7EA0069A883EC1DAA3E1F9ECE7586D6CF0A128CD557C7E5D7AA3EA97EBAD3
+ 9619D1BFCF4A6D64768741EDEA0A5B0EFBBF347CDCBE2E03D756967A16B613DB
+ 0FC45FA2A3312E0C46A5FD0466AB097C58FFEEC40601B8395E52775D0AFCD7DB
+ 8AB317333110531E5C44A4CB4B5ACD571A1A60960B15E450948A5EEA14DD330F
+ EA209265DB8E1A1FC80DCD3860323FD26C113B041A88C88A21655878680A4466
+ FA10403D24BB97152A49B842C180E4D258C9D48F21D057782D90623116830BA3
+ 9902B3C5F2F2DD01433B0D7099C07DBDE268D0FFED5169BCD03D48B2F058AD62
+ D8678C626DC7A3F352152C99BA963EF95F8AD11DB8B0D351210A17E4C2C55AD8
+ 9EB64172935D3C20A398F3EEEEC31551966A7438EF3FEE422C6D4E05337620D5
+ ACC7B52BED984BFAAD36EF9D20748B05D07BE4414A63975125D272FAD83F76E6
+ 10FFF8363014BE526D580873C5A42B70FA911EC7B86905F13AFE55EB0273F582
+ 83158793B8CC296B8DE1DCCF1250FD57CB0E035C7EDA3B0092ED940D37A05493
+ 2EC54E09B984FCA4AB7D2EA182BCF1263AA244B07EC0EA912A2BCC6CA6105B29
+ 044005DDBEAF88E0F05541BBD233977A447B469F013D8535A9D7023CC0FB7B49
+ A95CD2B6F18935C37F49E9A73E97A8602C5C26EE13D7A04A188336FCAB4CDEE0
+ 23DE9D803FD6E8D846B3F729BD36137E834E016242CD2F7BF048959DD45AD413
+ 19B985D05E5D422F3D0968375EA6A90FBEBF8B42B15F15280469D69629C08A42
+ 1C298CC027CC288B9C984239ABB96B6A891C1360D08F9ECC22202861E4CE9B39
+ 8BF27AAA00F869C9D899C80FDAA551B57BDFD7BF80857416501BB1529872AD2D
+ 6B3A52D684EEFD4DB499F42218289DB31491887F6E67FDDF52ECF4C3408C39FB
+ 898E1FE8A3A283CF7A503F23E306CB9F1B66B91C024915B720B3F9A973AD4820
+ A646512FCC46DCA3DFA130BBD64FD4417D6ED7D6819562699380767A35AFB535
+ 457CD781787649109DB5EBE59767E6463C73E268920E5E58F179A9FDA302062A
+ 90F3C917894B8ECCE11BA3B9BC0F3F08C1480176CBEA211BA456577DD7A0EA99
+ D3766E5106164B2D2FBDC79DD703388B4A17AB89914018A0F32B2382A176BFFE
+ 6722713469C9355C984268061ECA8F71C7B8287EA22BF5F4218EF59D9DEF2F7E
+ 34DEF2F7F537FEA952F5498B94B1C356A6B9040844F6A8C9F811330AC5B3E9F7
+ BEA1D9D39D86311A90049066674740B1D297B5118425D4B7E331E1A5ECF4D7C7
+ 21B1E574AA3592E56491D2F9910A7EE4A232CD8B2EFF2E72E403DA82B390A10E
+ 8DB6F10465D28D4C8686E6D88EF0DDCE22416090DC7986C8BC7A3E468B3E7599
+ 9BABD09AF6CF7FB216617CBFA2B0CC2BFD206C770964A716D49565DC56DA73B0
+ EC97A0087D44C9A0FDCD37849B90ECF55999A4A2851D0C37DABD3C0806B351EC
+ 268107866DDF69E5D40EC70ADF687C1CF6B9C31712390968ECE9D9E5598D26E4
+ 0783430BDC82EB7EE9C92BA3B1F305443C3B42CECC23EE0693B0FBAD39167289
+ 90F5C14BA0CB6B33BC53F37864EE637F2FDF11E61BDAEBF3AF55C096791ED46E
+ 8D564098B115849039081236FFA30E2957A8EFBC280AFE5EF4BBC389AA0B219B
+ FC9AFB676B35C630AB54E2400A165F69B0670DB3103CA16B05F360641D0EFB72
+ BE5EBB5AD933104E5407992B53FDC9E18F4DF242BAD0D5C23E216FE5B76469EA
+ FA8FB9A604C56E519653FC1CB84D4084E0A825B1B164F2D075F2BEBC6B8487BA
+ 4AA60874C8EA64F1BDC16C63BBDAEDF904D0B2654C8802EA25A285655FB265CE
+ EE978E64C8A3F0FAE325E8CFB4770CF1BF95DB45E5EC1E0A5999787A64E09F25
+ 25A87714FA94665F9F223673FC22AF79A0B2613A5071EB3BDB61BA3E183A230C
+ 97891C9AB7E66AE778918E2FE3F0559FB1197D2A83EF7633A4DFE883DB216E6C
+ 9FBDAEE4386413CE338053E6539A5C8F77CD9A9C1A369DF281BDC4F736FA42B8
+ A2F2E8E3CC3EB352202E8039FAAFA34F1E77929B25318E00BD5249998AA91D6C
+ FA4ADEF7D04E6CAA256425F4942061A5C4E65B8657EF95DB8F2C064D89F33A50
+ CB3008A421978C19A03946A83E08ADD6F982F5238733F6A094357A0033698DE5
+ ECE6D98416BAA61E916433482875E51E5A80852997D8A504BED5B944DADCDFA2
+ F3813CB99189CAC9AF23C681AF8FBB6F049C13177CF5E42AE6CD1DD4BE58A9BA
+ F432C3366E57671DB2836A609488F0EC18CCE4E6A3C2EA7B4F0066C5A4624F45
+ 6F62D4609DF40884DE638CBDCEE4A060B27F7164ACBBFF25FB959F3EB8755359
+ 1B504E115AF00AEE72482A013828D32FDD245796551D36BD3C71C69BEDAF9F2E
+ CFC2F206A9F0474FED6227D8C22FD93BD55A6792B7676D0920A3B7C19EB079F9
+ 610D477BF198882921C4448818B671B53C70EBA4129C9BEE6D2835615275DCF4
+ 4534C0852E541101F45A0794D395558B0C20A4499094A66677DCF8897F780C26
+ 917995AC5159925FD4E0B9BEA55DC3182B11F2CFBD7C0A3192A2658D4AC70FDD
+ 5C04A1FD6F7018885156A7A8511663749C23B3B5EC31CA526DDA80F2CF560A6F
+ D721F2017DA11769B78B8BEE2187DCD21DCB3F9F423B7E2FC7F27339B96B3F2F
+ 39CA1CC617694F54F11BE73379836943863C8138E42E2F035E6327680902131B
+ 58E0B209C9F1F5B48E13CEF741664BC3846989815A1460DB06F9B284F3E84DD7
+ D5131401C36D2E37D828B2B54EDF61F094B356ABDDD2440E03BFE58C2C359E1D
+ ECA9590CE0CB8040F162EE18A1B80E3B7D77E100B6A9722C5ACAED046E3552B1
+ 99518B07AEE8E6BA3E6F3349E6DF18D8CD849A03EF5F91E4EFA9220F59B10ADF
+ AF9B6C267D33D9B465269848F2D2E08B3AF996B2DCB3D0B075AD21901992B73C
+ 62680D3BB758A77566229BCB3A6B8D293F07C4ED516F6F179DC9E69AECC58D63
+ FB00AEC2050E8C4ED0EC9C8F9FB6ED879AFACE3B72D7394877BA5672C22D0DD4
+ 4C7BDB37D231C320181C7B6D4473CB16A0DB9DCE78C8602FD9B930B958C20DF4
+ 52C0024CDF7B482EA05C0583A8EFCD752A3F3DEDEEEE0468E882378CD5249FD3
+ 05FC0E8E28A8BA88A90FECDE75E6DF0AB0EE679FDE992B7D32FFE550ED9490BC
+ CF1238325350EF4C0B41418ECAC74ACD23BE03EE9B7D83E2983CF896C938ED5B
+ 692DB076E390D18BC7895B36FF542E08A571F9514D0FEFB1849A2166A5A40A6F
+ B1C86C502C9647B0C710CD83D0AD05E7ED7437F96607A0264CD168D4BE9BD6F6
+ 96072200B22A552E8F596F207AF4E215B9F9D02191E862F34A994FA2E74E9B81
+ 51E8A43305CE67379E065AD1E046F10B9917C168D52022FED0D4C1E8F284C42A
+ 35BD6A9F7DDE136F21798F11884AD97D21ABB49DDC0614E6275BFBB77DCEBC23
+ 239A8E17752F7434B0F55187B4F04BBFCCCC0CFFD2D4CAE1B780A8E4DE541482
+ CD20D9D4FCD36FFCAB41EDB5E2972A232F55D6AE24445035326DD99D7B220150
+ 37070442EC7BA2DC84FB4EC4C68E64349D2B4585848C727CA5A2A5965249F002
+ 4155493D387A1FE899C628BE6DB1C9E9E4941EA2636F1217DD4B0F2187858731
+ 54A3F80A02EB09C3D34BF16CA11AAF44EE2B5B8DB310041D85B317A9D0E79532
+ 153E7B2725F98D3B8DBCCC8A11A9957815C1BEE6398DD7CE0CB3BEE807AECD65
+ EA89C49E00A9D9689094DAF4210A06039E5029F337023DB0DB6803DD2EEA635C
+ 3CCFBD69CD900985529FC208D2524682F97002483E51AA8ED07AC7087EBC3F79
+ ED45884C10BF7ED44901B7A8CEFD675D949FA2C8FC1311933E31E066CDDD66D4
+ 828EC98304F8CA82EDE433C9620BC07EC1F3B9BB30836FA603E3E1ABE312A28E
+ AF4D0D99F5E67BD09BD8E44B219B5315F17A19125CBF46AC7A8EEFA8F767EEE4
+ 38DBB2296D68E153A8AEB7521A3AD4B2484D234CED1F5E17A2E9148D52C2C59A
+ CCD95E6BE525F4261327E0D70509F644A89FE8454C7FC848EE25F740FCCE05EE
+ D0C06A5991522BC60EF7D9ACADBF6E6503EAA1C04782A878C38EA3B595EEB9CA
+ B6A2E5CDC99387F1C0995DF0EA9E94E580503CE749B046F77D5B3EA22894A229
+ E73600D5A02FAAC96DA7E719A5AE51A217EC1D6C3E1209074B287C210015B469
+ E138B518E1E856622DC24E82C2BE5704C8817B6F31218E8A3C0D710096776494
+ 403DA9C56FC918C2B35BD46823A7BD15A635BEC65F2BF2518EC364A6981D76D6
+ E82B02AAF4C20BB7AFD571E199A6F5E40246BF247B6BE248A23AD4CA55AB7D68
+ 483D328E5789655880E4A1F7BE15AE6D98ED0832E184401E1447FE94C9FB4114
+ B00D19AFED927F5AB324E20DDA4B8C01E8AEE0FDA8CCE46ED31100FD846D28DD
+ B6CA72D984784E3CE5828864D5E46C28C22AE8132C5A3E2A465381E6916B3635
+ 6C9874DB427A3B8995B9DECF97F2D0D4CC847CB6024EDE26C44B84C6F7EDCDA9
+ 4184355335D074C5A92086FCACD784C2E90797DFA21591D41268B0D7046D1F82
+ 69C5CC082B3CB5D603D7E6F1ACD2E1D267CBEC879751B7DACF659972A140636E
+ ECA72B81E06E561652F6349C1935500DD8DE75F85F55A60A2E60F3007E1FFFA7
+ AD3ED695F0A6D5EF57B4056C7A7B7544CFAA12438B2407CBA54D09B183761BA5
+ ED01BA9E92308F410078F507715F8BE1412CB176EC568D7BA46B4D07D864EA96
+ 2884B2603F5DC2C7825A15194B57DF45E62FC98AB558D87772A3FCA7F99ED378
+ 546116DA04FD35F0EC929FFD168D130868F6B47AAAE655326CD25D3B2D8F1C1F
+ BBD52628FF49BF7954056C956B7DC18FB60881814002134EC64CF941AAD8D90A
+ E35E6925A73D32A428186909C9E2A5605B43EBF6DEB7B429765126A142BF0637
+ A0DCC10534637B5328F530E34505BF82AFFF08CBFE1CB908DCDF0DCB337EC7DB
+ 594718E9A2400911223C8706F6383C553910A2C2A25C1B451E41913CE2626A99
+ 6704C1CFEF5C281910FB616796FDCC9651953074DE62D0CA7424E88D2A4E4EB1
+ F8345E1E003C91BEEC4E4E7E3B2EE5E6888AA0C3FDC45539FD7D234ABDAAD4C0
+ A6220238275E21FE60A730866135DAC35AF54C32705E253C01132F436EB9F27B
+ 1496FF02CB6CF9E9356D747CDD0EE5E501658BE3D890CD80834F6F81AC78E4D5
+ 2986CF34ADB56E87DB49CD170794AA5B38DBFEB802A5018E600180190AB64EDF
+ F1D68CC6B3883100EA4123E2432C303895096C88BEE023939E210C8F1B52CF7D
+ 924DCB16663E720FB605352FEA9A1D556420B1C10EF00416AE636051F92AB93F
+ E19BEED4D6CF99800DD35FB2D63577C52BC937F2E4EF673E2EC2E9233D56D121
+ AAA906383BEA8A004C7E2A63AA5AFAA07D544564F3C772371624E84B0CD48551
+ 1C905FBBA630E299371CD1A7F4D2F13E8D9698150B616A8CFEFB46A235E41F0C
+ 2E982DB547F2586914FB0FA760CD44A5B436B405318F0715B46F702E5E45F446
+ 1F9AD5F8F9338D704F85AF013DF9EC6257E63BAD75F9466024FB8D55793E15C0
+ 35B18AEADDB1B71330E260ABFC1F7C2102E34EC0191FDAF598F89ABD93FFDE0D
+ A274DE7AD334B575D405F9275E9BC8C5877C724E44C8339F8F0163A0CFF2F91C
+ E9B44F3DDDD05E31F6B4D3B04B8B1386CB1B7160F5E0042F50C8A315B12EA7F9
+ EDF226CA8A24A5E78145D3B7C7001686805B4090FCC4AD5B38AB926A8198205E
+ 878D182D6343AD135012971225E00DCDC430CF2F7E516DD0015764BAB9196EA8
+ AA13D9C3229EFDAEEA7017806227B3BA1723F4DECB85F0A25B7C0F1BD8E2612D
+ DF2119C83A936FC17585EADCDF5C95C92822D0C4A22B19E7E9FB87214F040419
+ 5482CFDE7E2A1B76EDD5FA2610A71EC35E5D145575869BCA9D731EDB0A11406E
+ F95D33DA29CF461F78E40BFCB3DDAF090F9CD7A29F0A15EFF0A42F645F2D802F
+ 54F68C7B75B73F87343F0B87442290A1FB8A1E2682A7A99351EDAF4F60F06A6C
+ 5B0E66064171B21E2D8B56B49619A9663C7E2972ED9148E7A48AFC3647F3D558
+ 37E1F2AB26ED31DFBF544C335D0F21F39C60042772957C02452C451106EED544
+ FBDE48E70B02A00CFAC88BCF6A61356CF577846D000FBA227D46702CAC6E2C6E
+ 7CF852647812252380F16B91918633C66D4CC79F454646BE3D026E915712120F
+ BBE3CECFAE6E6DE3D6DA3EB1A195CCBD3BB42ED5B944E1D913B0836D3AEB0DB5
+ BF713132CB646FC63FFAB872A122DD2F3825E71FD92D2B836E06E7A7CB1D21DA
+ 5971AF771357EC19EFAF9F3BCF3CA55D88429372A7B86DFB10D7351AFFDD25D7
+ 0EAAF9F2B609DEB199456ADF278232CBAAA786241AC89AA849971D149E5944D4
+ 214ABB83B3C706656204E6C247B302CC474D181242EC68B3F49B71538ADFA881
+ F694E21DB1C39A1397014207FBD6A139E6FD0BD88CFFCDE92045E5302BA56B10
+ B744F0E9387E9EFC789ED65585696BDE3ACC0A8B2AFC1CAE05C3BD36061978D3
+ 208B9867BF9CD4AB26694050F2470F01C79C2D09C46233F5442B22F11048042B
+ 4BE928D54424787B00049AAE2770C0DD3ABDB632E865636E394E05AB604BC5E9
+ 7CB705AA10E8D3F0DA66939B4F53A852076A021A81B216475F009367FD364C0A
+ 6279830028951A8C3657E0F44B6F1AD9CFB569F3B14BED0A26E26563991002E6
+ AE28852CBE3BD60DF8A698E1509C5833C0B799165B35DAF2259AA535EFD84C3C
+ 7BCC69A0D1F31E72FF4847616623EA48AE63691C63A5BF42B12D770B6C2348B0
+ 649270CF31933EFDD05827EF33D88A4F10947198ACD387F22A2D81630FF7A97C
+ A46EB5E4E62EFE8EAA8638DEAF9063FDFEB74F9B5D331CF3DF3B2BE180C51397
+ 9B26F6FAE4127896CAB699914632C54C0C311E573671026094644F8D2CBF2C3B
+ 410F73CFFF4631D83B4F13AA06088DE8F6D8D03FC9FE2414986AF04BBFBC5D86
+ 065274BB8B60BFDF1C5E019804B177DF560726373B507D4BF54614674F1E7E3C
+ E149D83877420D97A33F45EE6329261109FB8FADC1C59A289BF739BCC1B3D60C
+ D6B81401BEE384719D9E9A7905964090797D3FC72C551E90AB1E1015DE869035
+ 5CDEF803C8FD0E27FFAFA596B851F26A505A4FDE343D1B24C3FBA57B790130F2
+ E09D3F487591BE42C0F2EF36A9F3461C0A620517BBA3E65A6FC6EB7F8B0210FC
+ 55C07D0E05A9BA68C2DA1264E626140993BFFDB7CF627BD32B0B262A3A4FD333
+ 34AEFC1910B037815C8B0640C049332DEC3AA7172E4B9F5B422B7835209554A9
+ 9C11C1DF2ED5246DEAE248668839B57DDC145ADDF5841BAABA1919193F12DD30
+ E03071B4CF2DAF24E9264AB1BFF0333A5E73C51EC270EFBDAEF493DE43A77EAF
+ C8AB53BA303161F997BB693377F4A836F65563FCFFBFEC22B054D26A56ACA13C
+ FC5BE98927581C1C366EE8EC5674AAFB6B804AE46B895F62AB8DA52072859657
+ DBADDDDBD68644A4BC02529306D19DB879177BB4D468D4603B9BF4083C357AA8
+ 9C277FDBF803FA184A57DB96A6302548B7D5701065E226BF86726CBCC1C4841D
+ 448BFA62C2D935F5E82779F2C1A9321CD071884DB54830BDE3932524120AB33C
+ F0A65BB913ECD418253321F41DDC98A64042B164804D86AB7765AC4D7969BB3F
+ 023C635353A56F2D4FFDACC1C011DD523CB78B58C2E7983EF43959F3674E778F
+ 1C10620D4582D2821272203AC04A96276BF733A04A887E9F2B64A59CE11704DB
+ 206DC94FAEB447C7AB63C7800C0B740D58564E1906333CA70A2F3F71E5FB7FCA
+ 14937D9C6A90750652F188D5E4951909639AD091F10EC2A3E9DE08E24B725276
+ DB41BF464B2FE3A4246FABCDAD56997816117CC997BECA00AC45F826C7F80A2A
+ FB315A2D8DE81216498CA53A40DC18140B5549CD9AD2D20A26DA6EEEAAF2EFD8
+ 09A51ED17E06BF7B045EC953D631E95AE0DAA3688828F64A6D4D103535ACF0EE
+ 2F86AF39ADFA6329BD6816D9E98D3B78CC3F7DE4B09F567A0E7934CE4B86819E
+ 3058D6B6C32EE0371E5EEBE0465C8B8DAA4521A46970B5E7CDE17E2DA61E0D6B
+ 23241F0EA1DBB8BFFEFD76847E447B4B0A6F565D26E373DB6DEC1567D2BAB913
+ 9ACCA0DB93218E2DD631B7D2ED42594ED01BC485570F373676BA9753740869FD
+ 3EA7900149765F1FD2ABCC182A4B9E98E5EBED8693E8C55791CCA73728D283B9
+ D5F0C078AAB4E9B31186D48289962A837DD8E423ED67FE6753C6A8DE6B3CB1A2
+ EF9AFB0DF36993EEB40C2CC4C54A6D6E8498B721567133301F58210250F8AB73
+ 3F01AA8D9441C5F6B3640A9E241A79533D2ED4C19466F3B1A600A397D9CA3EA6
+ AC7F0ED728EE6478A57B42EB018C4EBAC2CF73022869EFA5003F58415C778A76
+ 385476D153BE548CDC330D9E65C3A348A0736A36393A7830CE9E824AF45A10E3
+ F98040C62354A3390B8AE019AD3B0614FA4BE6BABBB993B5552778136AB495E7
+ 76E89D583E9CEACA6D52D33972A8100B6B28416D4552B3F30D214F2C7C40C3CE
+ 33D4B13D0F3A1C99753DD028D39BBFB8AD483CA68E4A84EFD64E6C4598367F9F
+ 5A8A5FFDE1691464122DCFC03A5760237853633E1B8EC57D7E3CFAC856CCFE7C
+ 1A6FD5A382C644841626F53D2CE3B1305BFFAD622ECA95E8E3ADC954A2004763
+ EFA307107FA53B2A5A7E6621DA0ADAC510D7C98C6DA9F98EC327F0294DE8AE3B
+ 4F3828F81EAE241D4CCAC808120117033DF71A08C86C4E1E95D7C0057A135BDF
+ D7C36722C71F67B0C08525F5E6D832F5043E797D1D603C3776E4B008C0F08200
+ 322D1C8105BD5AB3DF491844656447DC63555D4F77EE09C1DAD2AD077526B292
+ 15381622CC38E99ADDE443A284B898DC6BEA8CDFFB79B08AF9CC456B6940955E
+ C22EF5914E4DBCE703817679BB2AB026F8A17F4E9E1B8156797C0F92600FA5F1
+ 0686658925E77EE112E93E66F0C7B84753F152E9198DC1413CE28877F3A8C898
+ 758863B5565ECE8B306A69F42E99120C047AC10E3E10CF6331674276BCDEE06B
+ 8D90CA208BA55C0DF283BE6118D6E06E0FFBA4DD49D37AB62A10C1D67599D59E
+ E48AE9E09322774645CD335D383D96EB38D278405BA1B4C2F41BE1C41BBEB07B
+ CBD8BD69503C607BACF3C4F6EA8BCE24EC77395F526D4C6F50AEF183DE9CAF1A
+ 1E079B1F5FA55BC41C283FAD0D7FFAE86A4264DC5EBE3E0CAA35E414F100541C
+ E36ED43A17AA83BEF4A2EE76EB576FA3196DCDFEBE8AF1D7310E66CA00159581
+ E5332F08A2F9B5C43E83FC4AFCCA601D33840D6155E520E2969287F1FC9F273F
+ 8810841197E73E4804F710A35147F5B9B3120C140CDF5160AA15B7664CFA643D
+ 5952451E6CEBB252C4DA3A0A294FC8C3A24100E548647A9B1016CF3E64E9B4DC
+ 42946BC9E60449356A6C4293D93EC970B57AE346655A2BB288916C77549C7447
+ CAB16E2C50429A35439387043DB530FDE475C91D44F7B0505926A14F3C9CD7DF
+ D4E362ADF5C9650B2CEBDFC9DAFF74ADAD1DEBC73489D49666F47945B134FEE8
+ A8F79C5E18B8C9A25F7A0337FEFF0DF5748D02DCBC5333E392E1563E57F877F6
+ 57D0114DE967573B91EA208E1FBA535171877C5651528D2708698E0924AE9CF0
+ 15EB1B6D9CDC9DDADC939717E6325CDC48BCA21AC6C1094544C65EA7001EEADB
+ B0E7BC2AA9E1D8D5EE9CBF186B5A797686117A69890598B5CA3A21CF77798528
+ 59E289843C07B8C41982EE3B2EABB8F311D8431122CED0C2D3EAE1AE996F70D5
+ EB227F002DC05B151E4990B7237624FF94BAEAC53C517F7C8383E06376FA418C
+ E54D3F4C547DD207AA050BD9A658DE90D61D08A16ABD83C53AD2E894B763B2EF
+ D8DFB5055296D7B1180D5B2472598B61051CD3C2BF604C107E2BC41F3FBA146D
+ 9D499A02C9F61D0A830D6BFC7BAC1430D9B6310C52E1799B4A14D3B405FA943F
+ 3E845F989AAFA5640B2DEC278B0293E567FEB406290EC2B380A6A6446C568F26
+ 94EF97EC7E1D8AA4F5ED6A30C8D72C2F74E4CEB0F711BBCB349793293FDD31FE
+ 8D4A5BFA7E9FFE7A680C7DB3496D7066962A0BD3DEA3480D5C5FD8253FB38409
+ CD747FCB0FE26266319DFF5B695CF0A101A16026BA1EA0B6A866E430BE66CDDF
+ 34CFFFFC097F95063B28B5980BE8A466618D18C4171B6E1B593B2535B36842C3
+ 2FC14D75E840B6280483710BA72265F717253B03ADCE175A9D21896BF1737AB8
+ F6BB44685AE447A273B42616BF700289F6993635E2C0D16812376BADC49F910A
+ 2C44F928418AD065F6776F4932B24B96C0F9AB533559B38DC11AA4834EB59E50
+ DA9DA4922CE1F2E2F3DE0F1AB15AE5FB3AF4CC8C43D9A3F259560CC763BF1AEF
+ E013EE87D7673386982431B56D4CCC9A852D61D0AC7CDF55770A4C892A07B4F5
+ 1BB0E4EEF8A9F479D7D034FAB2BE9D2E00B3B50F978D1985677F746474AD256D
+ 2B68E51887BF95A95A03ECB9FE26BD3A001D54E596A2FCEE7BEE153C773FFC79
+ 46107F292E0D3D90F9532CEFF27DBFF6F5A8BC37A854D761C7E2FB8814E01E15
+ C858B83739022B146D0359ED79F538A19BF67ADB00FCB2B0B8127AF55A640EF8
+ C49B5069C1D5C2E8C45350D4586EA59A75DCE90E847E7669AC685F94285EB9B4
+ 740D028C9126B3CDC96A7CD3DC92017E14A0E5BA602CE917C67DAA6EFAEC734A
+ 4BF07690932A6E2C511C14E7B66B7BC021E60468E88A92C3DE7C55F74C6BFC92
+ E2CA7535AB5A1FFA77FCF2992EC7C8A0986FB241F68C75308546EB7CD409A447
+ 14C4C6DAC026E2B4935E7B1C1976F0E0AEC03D9091926D21C943F14DD35E4F7E
+ 7AFD30BF4599C62078868EA4EE1A125AD5D487C0926D63A166EBA80351F33BAE
+ 73E413398D6A73121EC44836ECE94BEF82FDE7BE2AE5085176AAC153C947C73C
+ 0460847211A25EB8071CC517564292820401B2DAD1AF7912644735CCAB08409A
+ 38D554D34298A1197E0D474D0A8F96814500E241D5E1769927CD64C02D76D3A5
+ F89A13D85211C60F617D5552F72819E2DC91D4F897AC739C8D6DA1EB17F3FD36
+ 6350DE78F3023516A049AA7FFFC5D08C128CDD5CC0D1D6539FAB41A91873D114
+ 518A98BD6813924B3394FF6AFA9F9B589D7EC329A2D43E23D2AC206365FD689A
+ E042E2D1F9FB5D8C3F82C308B33DA6850FBC45BAC2C13758D10ABBFE6C37190D
+ 1D70BF77D6284DE31EDF10C91F4185BE38EF0F9E9655A3F78AC263AA29ED177A
+ 78762B179B6657C550A6062FEA6D6304BCAC9F4C54B8D13C9C23C9CFD4711268
+ 224992BFFCA249472BBE1A5C37F6423853AF0B2CBB9139DF47B63A79E9A668CD
+ DAC7D0A1E2DCE96087D858139795325A1FC768DE7C48F2694BDD803A10CE07CB
+ 8AF269F9549EEC6827B4A27C936F07DCFF2B38B92453147F084785EE22E3BC92
+ 3735F935B0B1A71EE72E936173F07A3EB8C0F2CF03450CEA2AC414BD71B21254
+ FB668AB0AB603631533FDF48A56656172A65C3BF52D95BF302E0D02DD235592C
+ AA837005F295BDD4297DA81B3AB470F1384BB72D91B9ECAA3A862267153BAED8
+ 1AA9034B4889AB16A66593B5336C349AA95A078CFB0E899046498F772CB3BB63
+ F268F600A933A43D945E598F74B42BEE3EB76F2502AAA0EF34A40CE8243CE8DE
+ 9633E78AB32A776D7CEEA28C423862DD0A602CF3190FE9EC3A5F34F9018869B0
+ 6601CAD1991DE308C8CB1ABD9797C83FF9C0DF9931687A2C5D0D3E0549F06FCA
+ EB432FCF2D2322D2355886866B1D312522ED677584E05E037F002F15698B4F33
+ 2380CFCF769EC0A2DA8CD5B72210BCF0A510594D176996D68E963847FF661F50
+ B364B780426FD39080FFFAF6CDE4956FAA76DD9C2015712B66CD5197C778B61B
+ 8478CD13D2BB87444DDB81A116F322AFFC8F56BD453E4E4CFC56EDECB18805B6
+ 1A2E7DB571F27281898028EB75828EE0F9A294606FF29264229EA9FCA9EF87F8
+ 73790945A411C7CEDC4278DB10F7C1296D082AFB97E9DC9EB5595385DEC09765
+ 6C05938C94754ADC4482F28865D9BAAB485DBAC4C62F5E74F5E008FA9D617CC8
+ B71A9EA444E1AADDB81F78FE0A71671514E64A779B16FEF9255F391A9A80A3A5
+ E667313A5AD9E2A991C106DF3FBCD374BD63D35EBA7AFBD6BB67AE73A09F19E9
+ EDA0AD20D0070F497B41D0F24BA38B3FE3C979B4BE1CCD9931645D79C43C6FD8
+ 7989F1F2075D81711727BB2ADFCFBE2F7A0C1CE0DDE6FB27F67B58B8E0713EF6
+ 1438514D12A4AD0154DC0B60309F0D05DB174D08B4EDDBD8365897FFF1E33203
+ D2DC089764868B1715BC4E8BBE7FD6231814033085792617867295BD0A9BE5C0
+ D73DB4EF7A330D6522A89CE4999E8837CFF989A51F9E4167DD9C55C3F3C0CAB9
+ 9F1EC3551C61BFA44EEB9CEEB94995ECE853F321F19C1665D58F2E041DABF0BA
+ 8A6B710E4A3ECAF02A5FB99B06D15A7EF5868E4AD3A9B974630E8C2FA81D8636
+ 781B92DD8ECB8ABAF1E4B04CC3698DC87DC6C84536BD75478FD4BC3F9366BA38
+ F6F5139B5E98042F37EA8CC1D4B432860D0E145990799FC306D88714149B3799
+ BBDA8933C2F9832B0EE29C85527DF3BE3FB14B4AE6209019EE61FDD4E9F7FA43
+ 1855554387FA59503FD9F3E2B32AEC19F84DB9FBC55D549F021281B4207579AC
+ 6EB23D29F485784B0D93E43AAD9FFA9ECA7F5568FC1244A4D677418D20BE2A27
+ E5A97D502A7A220F28E474EEB6BC050CF7FCCDBD4A40224EC4D288D3F97C714B
+ FD85F1BADAECBD0C07912C2EA859DB94A6AD5AFFD941E88B2DB2A2A8A12F7D64
+ BC42B95D11134C52AD68F41AD91FED37653A3BE3AD1179EC472F05762E64B690
+ CDDD30CDF9B07BD991493A7A9AD2FF4279461D414AE190E8929FE3818684A225
+ 7EFCC0C785D725AE92BD77F22E45C26635C8AF43088157234AFCA4C95ED74F91
+ C94D1427ECEFF122F0900AF4AC77F8B9F776E1BE777A10DF19F4894BA6457635
+ 2D9F783C167C5091DE115DBD85EBF2940C57C6439BD39185CBC5D74C5CC07B9B
+ 473B8111608AA44BE6B4148066EA84ED6B2E64608F2559A59CF63DF1AA6A7F1D
+ FCF6A44A6F37EAE1D28831F283BB9730D4CD664E846CE3C676347A753183AC95
+ B31E769F453A66B8509E72DD46EFE8EE453A85660658CC4F80233F93D3FBB681
+ 1A97A3349450EE84A622264F650DEA4A0281DE970A5529DFFF69A8429A200670
+ 6D3A7B3BAFDB19FD551FCA36DFCE7389848BC12AF28741579820257A5A4AFF61
+ 6B8EF8323D092537442C7481DDF3C805688E8BEB34337A724BEEEC569AF1E14B
+ B29AB13A0F8B9BF6E3980904F26937295B5976FF55662AD17BE4F1E0FBB877C6
+ 9232DBCFFFEB7663440E16ED1EA15F32E126DE6493CEF973E4B6138CD96C66F3
+ 6785AFE632F065BB61C23A958787B5D4C3C64FE0B298691B2EE6B1EF66F7AF41
+ 57534005B9893B3BD9FFB5AE9A1B0350AFEA73E6B1D0C2F8E39D90D7F39DD94A
+ 80E121709DC311FD67CA8B5521B1C96AD062ACF05640117243A227C486EEB342
+ 5E52B49992FAF11693AF95CA9133B9DCCF0B56F71290655A9B12B8614B6EDC1E
+ C5716117612DF2CAD59D93E01DAA0156E3D683AB185F0D358520DE1B926A6A98
+ 93502D4631249AADC6164FFBAD521FFA5433727DF9873B5289C13FD21C0E2D49
+ A354831E99B39BBD8CAFFE0BC9C39262A639B3E16198E022F66D91D6412BA874
+ A473F04B686692E3CA2EC38D2E9D5A728E012021675F0723565013E47E7429AB
+ B1DB28C32401CD1175D38399C269E7332ECD9817F7BEDEEDCAE1C493C9535303
+ F7571D3747AEB195C39234DD26A9810C7BFE3F069E90D2556F83BD79AD0C92D9
+ 658AC30F303FF8EEE7C5BE85BDD57630670F5B4DC1045D1C0EEA97AE04C97C1E
+ F95878DB990721B2588EC5B1F19368F8D9EE4AEAF29619EF5793773AD3599C27
+ 25714F64AA46263B5E709B3378CD85A9A5D5BC7B50A4548B8AB94F190EBF52B1
+ FE9E58DD67AEF2B71FA652644DBB16719FB0324624CDDF2A3062BF580196D25A
+ 68947E4F3B7284136FC0AA41E1E0B1F35CEB9274045398B252438F7129841C30
+ F94D31CC955627DA88F87555D8DF303B2754A09C684636989DDD25041562C4B3
+ A7DC6A071AD39D952EC0E2D3B837094437A5CCEF48FCB10B1D49869C223D72B1
+ C0D64567AFD298C378E6E62B2539F6E3622EADBA8936A33E1F7F00911EBFB026
+ 3F74BA13E9C98D02325CB3512FCB207AD51B9C745A3B707A8BE6A3D8FD1FEDB1
+ 7DAE734E18C1CB8AE56C4296C2372DF55D92A78883D574F8F8E4A67547A40EA1
+ 25CCF31848BDC09C05B06E07AE0065BB58581FD1B86DBA825E91EFBBDBCCAA4A
+ D0142DD08711F540A3DCB23CFD347D97ED1C24C74249EDCF4C32F80DA3F9CF94
+ C24776B697517D66E52027DA374C69D4DD923759F5F0D7CDBE428F7475F8CEAA
+ BA2B44EA76756FABA7C2908B2B3B3FD3B9126983CAD27C00A6F7184EE8D6F4CA
+ 1B27EAD6EC7243FBB04FAB5756910A626A2E9D7E72F28D00F4C0D50CAC6F11EA
+ F3DD7920108EBC3A09EFAF923E159AA484A4DDCC6A2B374E8BC1DBCB9B18C443
+ CA347E89B45F88D53B8F7A4081B5D64C401ED5AC0EC763F40DF9949E9BE28E64
+ FA6C895148B3B1B0F474331760D92DEC6CE1D1D1190271D8E1FA5E05A10A1599
+ 084F95ACB3F66BF98DED70ABBBDB4E6C5203E758CD0F6586B66576E2FE7084E6
+ D8D644E7A7284D4C5B008821D544748ED166B5EBF2BF82B851B8EB4DB62D8245
+ D766F606ACCDF181CD559BFF72C0EF190553987AC44BD99879005DF183586EF1
+ 51742DDE421B5C5FF4015CE06A864367DA922A8DCF68EE5D156DB5629C6E701C
+ D650BC54986941F771E291013280413791383F4041D2F86B7369C083F9B3BCA5
+ 59BF91AEA6BDBD0F052117876B258AD0BB84FD23C058543239AB3BE00400865E
+ 1716E8F628B090EF3CCC989600A4A952CD02D86090687049B5B1C48AF6BCF959
+ 3D5D2683129C91451673354328F25DB32A3143EB14DAC97499138ECBB6542E52
+ 182502EB650D3BDA1AF488FE60C2428436C05DDA88E0A3EADA71BBA8CF7BBB50
+ 871F4AC4991749F5B77A3BFCD60E18635065A2F08A46E414B4DD4F9A14255914
+ 3012EFE8E2286FDD32D00F724AF7E0D2CA61E7A1F379358CA1804B4F
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMCSC10
+ %!PS-AdobeFont-1.1: CMCSC10 1.0
+ %%CreationDate: 1991 Aug 18 17:46:49
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMCSC10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMCSC10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 97 /a put
+ dup 100 /d put
+ dup 101 /e put
+ dup 104 /h put
+ dup 105 /i put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ readonly def
+ /FontBBox{14 -250 1077 750}readonly def
+ /UniqueID 5000772 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D5993DFC0930297866E1CD0A30EB76029337
+ 900ECFB1390CA5C0C3A04528044F266BA17BE487C79B94FAC6D6484684C5BFEA
+ 87BCCC77D40AD11552035E95E3007126418ED49B68468B38A14E88E68A267B98
+ 076F1C9769A5AFBC285E5B158EAC9F926F1D6C0B8F1D57D9C31D25AE27123518
+ 9D2CD92E5689E0213089BD268DA5E47525CB8EABAA4B78A15AEA34705889AB3A
+ FFB8953B5B3482E52BFA0940630ADF8C0AC2177D907324299EE980E850F203CD
+ B627962F43D5A678C44243CDE97853BDC6AB45FD5C09AD274DAF89929F583CC9
+ CCC24BDFC68B92111055ABA5F26D2DC67C70906F71C2957701D65AE746A60C30
+ 40E6CB24B97FCDAD0487AE38A201FBF0E41BABD2181981A71940F1E707F91E5D
+ C8CA50CB16D8702D188E56D014D92F76CE0B52ABDB9110E32438D2BBF3E6A40B
+ 7B005F10BB437812CAC6ED2996F7606DC962C4FDE207FF322782C343DF44CEC5
+ FF06A55C630C20E9AE1B0D1C5673753C43BA0767D65D1B451CC6380D8BB3C4DC
+ 81E8FD8AA79BE993218686F29D3CD925566DD587F541A0DA1B1CC3BCEA2E6C7D
+ 5E1016F6917A871F1BBAD96AF9E867735017119A381FCF33EB2D3E1E7093FD90
+ CDB0CED4818CFD9E201A03430CEC713620BE0D3254158931FB657C6AD4B2482A
+ 0E7D070D7497892E9E942DF58E88CAF0C8221BF36BF7C435BF2C683A4A2EF4CB
+ E85820A8AD3486155A40143011BA9D76297F46DEF69ECA4596D6E4CAABF84091
+ 22A96A4BC78A8DD072FEB759A68A44BE1164638B6D952147EE3C628F9A022060
+ 1D1941E73310943FA782532ABB1116532AD67AEFE0758C051241E301C7E13A98
+ 6447EB0180BF6799814BEA4DC0F727D0A40B7BC3B1269CDE174453D6A3C4479C
+ 146001CF717DE25AC1BE5AEA5F2F1C17719251C429D3AED19EF8CBB7F86CDBC4
+ 762D501F8A6DAA2C002FC0657706309C1DFC1616B112EEA0C7CED984BEC0FB61
+ 4365988AAB356C9E0DB81E1E650A5B27AA849894709525663ABDA6568CFE7757
+ 7B1B39F844D2833C2D54C2259D1350DE179373385BA5FA35538D830D5C0426C9
+ 072328E5877930F9875DC41505C7B41CAC491BF55063BB5B41B8FBECEF3C7207
+ 342F091B85FBF78F14E87A0F8FD6D5A1D5BC93A5F707DFD9808E6988123CCEBC
+ 94CACB0DCC1DF33156F7C4ADC0A98F99638F7E4B1D02B3AA3C28C400B9240C18
+ 1757293B98A97BEAC45354D1D88551248AE1F730F879D21EDC3D338DD21A8578
+ A7BD21580598A714441AA2EDB2D7B1942711F6C0E26BFB3CE83B82473382118F
+ BB50A3DA7BE1360D9120D74C3410C6DBBD2C6597367275EEDD1FB962722DB1D7
+ A97FCE38FD003F6D2BE36C01132694AAC0EEB943CB3CF98BDE005675B8D8808C
+ 75E3E2544C4B070FFDFABDEDB488BCED52BECCCF476136D713814BE1FE729F44
+ F9EB6851F16D5AEE9E911B3907D7BDE4708EF5252DF300299D745DC085C593C8
+ B4D05B00380CD7E33B5628B4AF82A87A777FB4B652205B40CF3E30DED9B900DF
+ CFB97375FBE622E2DA1956F4B2923456FE9631D358F2FA9CEC48D32E663084FE
+ 3F1C1F182CA8767ED63923C12F5921C3246D367D4F309F38FB5234EFC5F3AAAC
+ CA35F17336F0466FAE67AEE36F3F794FE0BE1EE4D87695A573C902FB49247987
+ 49681FCEF89BEDB04751B93C38A126BF3D547BA4586BE72827F98C2334BC5FC4
+ 0BD9404D0EA14CE0B8B0ACDF54FD8039EDD22E4CEA50BC5E9979B4853B5A6F8D
+ D745EAF594D00A68D827A87B706495461970BB20FC7504CA17D21F2477AD5AD9
+ C188F3F07A5D5CC2C7776E62B0BFDD4D2C370CF1EBDC4164D29EE82CCAE52817
+ AF371CA6876E9EF2725B88765CC8D19B2D35D50686496AD662F124B41BA3D2A8
+ 55D15784E155478F5F29004C096F9BAA31405E7156AC0ADE29C46FCEC243CB3D
+ CABAF349729DD2FEF57F2ECB6F093A95270CF8A7C9F5574287ED6FC5328E38DD
+ D0E2706B375C6FCB5C75C9C4028F25278B46D9C68F80A6C9CDEF6CF9B49246E7
+ 30B42891D1F22A4E1C363003ACE981E34ABE3BBF5CC63965BC2E6189E1F69062
+ 0DEB16D1ABAC80B76BCEF703EAAF64B46F11A4B559FC09A3E9CECB4A67AC6D3B
+ DB322AC029DE1F847CEEE0667B2D25384DE8C79285B2088778D73DE2365CFC38
+ 4C3A89201F7D7D7A9207B4B409DEB4457F5EEB33F5E290A5339BB85C3B288CCB
+ A6888789BAFC89ABA8D4ECA0B715C99BB0F494D6A019547CBE291A565FD42974
+ 36B7164C6DF0DCE813CFEA73E518A5D064630CD22BE0C3750C56D08F0B09831F
+ B265718C4FEAF67EC780BF08D447C41BB1053373842CC542D02CAFFC82874BD5
+ F17193ED1DC758728569A600DE8BFDDF59104C1101AFB82A3178E15CFF91FA2C
+ FB93A5DBCBE3089ABDAD87A707F7917B5F99D3B9530A3F98E5D43CDE0A507585
+ 7F5AFABEAF26CEE0B4E6F09942125FC248324C12D261B782F1D063B7FCBA7304
+ BBF4F882F7BC3DE395F8ED02783A8BD1B686673645FFF523113391C85D9821D4
+ 40965B7744FF0C78F129CAA831AEDDA052A3FB9310737AE5474A01F377F9307E
+ 47DF34561BBD5BAA7D469AC1DFBBA881CD6EA862F237C7EB567A827F5A31DB16
+ FFDD12C56C7856BA0DE903F47F168DED380170044B9626183551290B866C433C
+ 7BBDD29116DD91AD711D85BD40050036E45C35B9FFB0DD495E949DD439F517E4
+ 380E624E5806BD98868F42A75743C9E467FA9BA8B05757E4B3A9901919D88CD1
+ C8B2F0EF81212F90FA27FEAABF0F26FE713275877539A20C25C6811D37C96BCB
+ 524470E11CCB178D71EED80CC0E4C9744773D41028FA1BCC02842E02D590E903
+ 35079D03E696EAFF11788299D3DE4DB0DA990CEA2430A53669C649E011C9E071
+ E5BFB9E5B7BA022C7153DD3F5F766D19D0E961873B3AC74346457AABF7B3A32D
+ A6808C9559C5D8AD11DA5FC631E356B636AE2DCA7C3501C237C13F1E3927071F
+ 030482EBA488787D90DD7DEE02C447AB3B41B0920293009B72F02C1B3E5BC762
+ A33EFAAF87CD3C6CAA6251B9689EAB38F37752E253057C6D12223DE09FC6C839
+ 1D2BD8F998F5E6C3DF7B7EFF3C136F8D44454CB8514771DCCD369783AC9B48FD
+ 5383678B04992C78BA9E886DEEAEDB938B4F78FC7FFA8662A01C139A3EB20B27
+ 3C0A5C42F596685C443FF09352BCDBF31EA245C2B988A0AC92F2A5C5774A5F81
+ 2C42391CF3032240590CA2B71B1DCF4149A2FE6157BDB2B75BF8BB489CAA001D
+ 203FAF23A3ABC727E651E28810D5E831493492D5CD5BA2EDDA963532BD10F951
+ 9B559967C49457F94CD6DDC8DABA3D5CD756430E606FF35CE1499E720F880199
+ A37C85466A509AFA184DD4E4EEE3CC110B404DFB015D9CD59D975E81F719914A
+ 0D30D75BC1A14B85B242E39E9A4753D4CACC1BD21CC37C5A82A911A08922D8A9
+ 8DA398FEEA0A42AC56C23F007E8430C47818C05BD6E1AE56966BCBCF5FD10E80
+ 285D6C0880552F60F7526AA7EC0D9167FC665EB8F053B17CB3B13179B9F16D23
+ 951DBFC88AFCCC7E76031A638F70798744684AD03A1078B4A52504200AD1B347
+ AE32AAC359DC37D3BA3C4CE6F21BB16E340D20A0FE75018AE387EC92996C6733
+ 1BE31D00191E461AD2EFF4AD9F32F39CED3FD1261EA3768A83DF81862C2DDBA1
+ 237CF90714AA15989E6895C5E91D3A406251B9C29333737350C9D0F8A9FBD95C
+ 45752132179ED4C99AB9277DCE50895B4ED8A0CC559CFA151D70D7476E26E877
+ 031B346095B27861239480E99858BF51D1155E0199C65048AE13BBD8DC698517
+ 92BFF07BB7FD7110CC84157A01653249794E03E742E28C525C1E6D0BB57549B1
+ 0ECDCA30EAA34943B74FCDD4DFC126E673BF9EBAD0C3E6A6DA4371B8EA684818
+ 69EAB2EA00F4695F467955969008C0491B85C523FF4ED2F63BA4DB0DECD7E786
+ CC140D2BEAECFF7393F2B928884CF98D3855CB1AEE798FF92F78918C03A2
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMMI10
+ %!PS-AdobeFont-1.1: CMMI10 1.100
+ %%CreationDate: 1996 Jul 23 07:53:57
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.100) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMMI10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.04 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMMI10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 14 /delta put
+ dup 21 /lambda put
+ dup 30 /phi put
+ dup 60 /less put
+ dup 61 /slash put
+ dup 62 /greater put
+ dup 65 /A put
+ dup 66 /B put
+ dup 68 /D put
+ dup 72 /H put
+ dup 73 /I put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 97 /a put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 105 /i put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 120 /x put
+ dup 121 /y put
+ readonly def
+ /FontBBox{-32 -250 1048 750}readonly def
+ /UniqueID 5087385 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D5993DFC0930297866E1CD0A319B6B1FD958
+ 9E394A533A081C36D456A09920001A3D2199583EB9B84B4DEE08E3D12939E321
+ 990CD249827D9648574955F61BAAA11263A91B6C3D47A5190165B0C25ABF6D3E
+ 6EC187E4B05182126BB0D0323D943170B795255260F9FD25F2248D04F45DFBFB
+ DEF7FF8B19BFEF637B210018AE02572B389B3F76282BEB29CC301905D388C721
+ 59616893E774413F48DE0B408BC66DCE3FE17CB9F84D205839D58014D6A88823
+ D9320AE93AF96D97A02C4D5A2BB2B8C7925C4578003959C46E3CE1A2F0EAC4BF
+ 8B9B325E46435BDE60BC54D72BC8ACB5C0A34413AC87045DC7B84646A324B808
+ 6FD8E34217213E131C3B1510415CE45420688ED9C1D27890EC68BD7C1235FAF9
+ 1DAB3A369DD2FC3BE5CF9655C7B7EDA7361D7E05E5831B6B8E2EEC542A7B38EE
+ 03BE4BAC6079D038ACB3C7C916279764547C2D51976BABA94BA9866D79F13909
+ 95AA39B0F03103A07CBDF441B8C5669F729020AF284B7FF52A29C6255FCAACF1
+ 74109050FBA2602E72593FBCBFC26E726EE4AEF97B7632BC4F5F353B5C67FED2
+ 3EA752A4A57B8F7FEFF1D7341D895F0A3A0BE1D8E3391970457A967EFF84F6D8
+ 47750B1145B8CC5BD96EE7AA99DDC9E06939E383BDA41175233D58AD263EBF19
+ AFC27E4A7E07D09FB08355F6EA74E530B0743143F2A871732D62D80F35B19FD2
+ C7FDF08105847F13D50934419AC647CBA71DF74F4531DC02BBDA22AEEA3FBBBB
+ 407E0ACC52BDC60D01A29407CC4F93EB8BF6D4813E9BA858D54F38918AC82720
+ 4956D50291F0546E50FCAFA6DBD0099123F5ECD4AB338DB310DB4CAE11337A89
+ 8ED99B6F483940C97544F888EAF0CBEB11094A13C073D0061808662A04A82BA0
+ AD35E8782F854AF66C20C0FEF18D0ECDD1646321B93D327E53D88CA0E825FA95
+ 05AA57BD719DBA131557E586637F85D3FAF7F0ACBEE719935CFEB859587AB92F
+ 4A78712F2A94C2A5DC7CDF95196924155ABA19BA65CB3AF53BFF7C66E2896EBB
+ E2401A5EAE93FD617B377BEE9E31F1B48BF08BF7EC64F5958E42DFD2ED31C3BB
+ 9C480D9D68F0147034565C97A6764D4ADCA3EA4B946EE03807C57D461911900C
+ 2D049AB651ECA3DC5BE9F0E07CE1D7659736E60FC2F56890FD086BB8918B1A68
+ 6207733555129BF9DC43CFA48410B6B456725C21844FA31B1B6B62F748E138DE
+ 01F30ABCF830AD905B82A16D816BA23593810F9782083B182FBA0919B7E7E0F3
+ E35D79334E85D8E4AC20062F22DDA1E21FBF8E9BC7ACD5F292F6C9DA52276C83
+ 915383798AB5EB83FEFD9F9D3F11F9F6CD2AC165AD8181D914355521C441D899
+ 07E9A53C316D41DB737AE439F3DDB9DCBE12366B2AE28AADC3C1F0C3531E3660
+ 7919039630087209FB6FCDBC3E61CB57B16A8CF3A4A5C0B6C19C7315B4BA2767
+ 6464588DFC7CD84A1616ECD7685A67764CE01282BEACA2FA5E3E6441CE5B757D
+ 317548D0EEBCFE7EE436F092D3F755442CC21078F9630A33A02D1DF546906696
+ 3E014FECFFC85EF4F7BD72E87E537691ABEADC5CD1C2BF8ACC4A2761D24FEF00
+ 9D20E58C034FC2A342A99A0C3CC4B7E9DA9EE0E140AE94122EF4BFC3B28A5658
+ 80CA638A9CA7A1B613A3FE7EA075F5F67C5BF3E40ED7BBA89CA1D5DD2F3A2CDC
+ C90642BAD724127C0147C26DE5CD858FB2D4B42F438BF9B257BB5DBA73DD2B7D
+ 538EA423293003DF1A5E0E30E04DE6295881C484B80C9D660EA9E5119F9ADFB3
+ 72E689DE02F7A43AABCB5942314E4DEAE9F8DC160948A0C73AA0DA0667F8124A
+ B2A0F14930432B848F7295E3181214D1D469764D780D1D68570F99BAF5B362A6
+ 3A95168C7707E098A4C003689EFA21AD7AFB337FAA37D3E7BFEAA7FA95B08A83
+ 186AD9AB35CE95DAA771198D60CF3B5CA02DEA4F556BBFDB2E84D33D7E2279D5
+ 70CD41D6F9DA4897690EDD9D7F2353F862933CC65EBDB26A7E235D57B1317BA1
+ D6CBF21205B252231EDA1F0116D4B7D4F18FBC78E0F8976B181C1FF3E6B8258B
+ 3A53F66D2C0C76C062E522B1D9507A3BBE42716727F23D67707571C53A69E08B
+ CE09A43EF983DAE62901E655C9689C912AA379E9761AB1F5299930EBD507D6E5
+ FBB42850434F485B8CA82E6F5DA4FFFD8484ABFE80EEBBDDBA2294988EEA4A3E
+ 25D7EDD57B82F0B11C4C528CCBFD85121C0ED8297E8F4841011A918D2A9D1C3A
+ 1384D7A76B2ED175360E3A3C18F12507CBA352237EBC43ED03D53CCCFFDFC63B
+ 9E539795AAA1069C180B02C9A0482B3D910DB4AD53956AB642770B46949BE4CB
+ 63D680EF6F436F92F758C4A1241445304A89A234E70E13947B75853461B167E0
+ BED09F20EBD708831ECE9990C61E6E37E121FE5964C15939DEA4234F7223A2FE
+ 0D4FF484DE9FEBC0E841BE147E28D215739097326E5E60729CA1A8455F5C049D
+ FC8547A78D637A4FE5DE6FDC06A595399C24EEEFF85CA83D8D5181C64724657E
+ CDC7D978B5B2665E11933BA77A283ACB0DBDBFF5FE0D182FEE1825B6F893FB4A
+ 01343EC08383327E2F22FF2040CAB950AA0D3625202FA5DEF9D466ECCCB8138C
+ 1FD86D56335DBEF6EF1CF531D7E52C19C9593B4B37CFE1A4E90C1C3F285A7C47
+ 7E19CC0323AECDED6CA705A33B042F4268407738C434BDE9364790BAAF9534A2
+ 689D6BF8E9D51A935EC97780717FD5DE3E119DF64030060DD62BC239B0BBD77A
+ BE4FD32B63F1A1463FF8E2FB29F93AF1DDC072239DE3B41A231BBECCEA0DF3B9
+ E7158B14C489A7C244AC0DF7F92C12E3882D55B6BC5A05FF6FCFDEFACBD50D69
+ 0DA32A9DDC4C26C1C41D81F5FD89C7FB13877BFCF7B054CEE0D85E437A123D8B
+ 6F665778538AB9D0EBB0C3FB6792A9F01EB5E91EC77A644CEB1068B20FAE838B
+ 0D97EE0A5C8A549EB00508D1BEE79E842487D2068A27B97CDC6580191C6B8462
+ AD68AA38470B9F440369453A9DC92E94F80286578227BC7D971F1456184CF67E
+ 0BC865C3C09040C344631E43D6A92801AFFBE4BD5B62B1252B1E37F1870D001E
+ 29DEF2ACC71BED3C2CFEA49D3FE80D8470835C45DE23DC2C2AE4B8BB1D6806F3
+ CB8CADAAB5908D4EBC17564C0D9BBEEB576507EA3A90F56F2B751C8EFABE107F
+ 0B843A1EA158E166BE1B5352DBC727AA055DDBDFA15BC22FF5678BD665956ED2
+ F2641282D73A3ECEB433430E3771289431459CBC2D80BED3F2F376F1D392A483
+ 150E93CDE7DD6F574E5900024C36C59BFD2DF367B2BF3423D7AA436EB7F08A50
+ 3CA18F4F16EE99396AEB73850E8F7285F655F3E4E20F4EAF7F80B6A60796F657
+ 91B970CF4B511E2B2438C9B72FB7D5CFC75898F627F8F96BC420FF27E7D07A31
+ BCE716B2A715791C05CC5559B4666982600F917C95822396047FF5FEE8301084
+ BAC310B6B4F2EE3C6B9A4D05D55B1C6A6D1EED9AF53A6BD463DD7849BE2F34F1
+ 36C96DBF88608FB16672DDCCB8B85D6E64434B82CCBDFF455A86C977C31A9E5C
+ 037781CD9A13615D6029913C932A1919FAFEC47BBF8D1C6F5117859C5110345A
+ 316BB35BEC09A875199DCCC9C6665A7F2D19FBDAEBD5C8D8352EF7E51CCCFDBC
+ 709B7C08D3D4BAE78F1DE9C49CC9EB0A6EE8AF00ED2EE307528AFE3914B12C28
+ 684B578B41FA8DF087B8C33A668D3D2F0226BB85E71D4E11E7C1F2620801C512
+ FD7D2A62A7A507BE96A2C0B61E50226F7F352A873D9B20A5783F4E52DD603EA9
+ D5C072D87652C87236E76C8006D279A84DF807DD561C7292ADF5B660AAB98D45
+ 50BECBF3726949AD77AD95707286E1E2DF1F417B454F912B41CEA832B6137F55
+ A9CE06B6C8B52F23209BF997B485CA4DB58CB5BD6BC7882D050258B822D3AB54
+ 8BD544E23BC589C30B44B580BF29C2C317FB7CAB6C6E5D7CC58566797EAFAF3B
+ 8046FDC98BB767F43E2A16C342D3E8A0DF624DD9C9B256B833C299C3E6D34D1E
+ 30D4A7CF9AA78008BA57B8B22B198E138E7BD46EEF02A6BB4FCB9EA6B37D8910
+ 0921EF4BA50EB319F6F280884320CE90509F45F3FB49704E12BD9E04CC198FB7
+ C4ECE4974BD4C2114CD2AB930BB008F5D15DAD45467BCE6211DF60D2BDB6A951
+ 5946CF633D11E31A328A9A8672E09BE5E894E5B09612A748634345D7931F9D42
+ DDEEDCB831B9A07072BCEF67ED56C7CE013DAF423E3AA1F5A5BE66C0C518ADB5
+ 97B1DE2A0A2F5F33EF0BB77DA09DECE807231AB8200FF0D5ACE8CB76C8F9F9E2
+ 2E1594CAD6B49101E473E54E23FA3DBF11B356644E8E230466B0271BBC9E3774
+ 79BFF9C7819E229669FFE852DAEA0566E42C4B12F4D07A11623B92704C9BD3E1
+ 39C40BD0C45EC2FF20799340BCD643301E0B9BF587CD46C1583CDEC49D81B3C5
+ 534236F0846E88009111ED0043846A1761F7D7A9251FDCE14EDFD356D8743857
+ 35B9FF760A239C3911019A689EA7E43918979617FEA792B861827AC22DAC72C2
+ DC5932DF734F218453960E17B4410A194F64119554B57D2A8CFCF49722A9E046
+ 8966201F629F19D11D48361A3736A5C9A96046B0D52A314C753A4EB511D5EA6A
+ 0955B2D6BFA4D5E770FB3816115D845434A9908ABA7B56BA2A981EAB1285085A
+ E3B2D2F1202FAEC0510F84F4051798D10E79FF272E472D3D058804C872AA21B9
+ 0E059A4C315758E332116B7570DCD06F541B5775B3324A544E9FE378B1D0F743
+ CE2688ED1E74415D3F266FF823EBA4FCCDFE001F3571AF556C83C06C323C27B7
+ 3B222372A12D77C787732FE00B9C2C8B87C0E050425311EF50B1CDBA748C05F0
+ 20876C564D674DD67288927ECEF9AA3F3DD5B3EA9BDC89432582810C686E4A8E
+ 45B5AFAE37F444D37B56B50685C3C8ED0BAAAA020321491A5CFEBC940B6E690B
+ 48FB75CD54EE46A6543D288C9E97CD60CC6E9420A72B4F89991E9AFD4D0DB6D9
+ 2B3112E05B2C762A701D005576D60946405CCFE5CE31035E50B0B8ABBCE5F985
+ 2C9BEC6A8479055D55CFC24869634063BAC7BE0C963916F6C932747E17EAA5FD
+ 811FF80050B3639FE7E0E2DB98971D8ECD7D11F77A953C455F543B7638994A14
+ 80079D2D5D942141B5EBF389C5A771162B6A85F8451E2E16CE860C6CFFB755E3
+ 658027ADF54314437018744BB59500CA68F97B02E16611221FD681BDD76BED3B
+ 5AC206681C9FE8EEE9A9F70B6415904C6CA010D90CB0245E22D62D69DDC09142
+ C00FCA39DA8267372248A8065E8BC49F0373BAC9A7676600AA71DD901A3C3B87
+ 831D8AEF7055F78C7FFF87C2C409BE5C2108350C22031A80E5C040F13D2A1914
+ 137A298AC19A140D6DC0C92F20D3FD424005F110BA97415815C9E635A0888C49
+ 80A4D7EBFBA67E73E0B52497A7618E5123A49F41326A4F8E3B918772A8F2A879
+ BCF96BA8E29552DF85ACBB78829BCB3E9BFED3F5AA50B9B4EC577D33C4362CAA
+ C53256D0A5CE58C35E4CCC140084C156BCC9155AE0D4FA51E0524B7B9313EBAB
+ 8345738D062EBF20F2FDC7364D184AC3B224569561980EE346C44157C92DB440
+ 7CA425E55EA619BB167967B6C0825D74BDEB0AB92B27EE167A66E9C0B31B0E1E
+ 694611F110EFA4C610AB69D2CBAE30B9965293A42E79AF26AD212C8C8C38259D
+ 39E5EF869AE97396B8EAAAACA5F6FA5949C7334B51DD56F6719EB97D2554577B
+ 475C4A88F36FE088734B67EF2A2D174B54105D0EDDB553C5916085906BCB0853
+ 1B4E180043DF1627C534B65E1514DC9E827453D844FA0D53F3031623433DC09A
+ 50A96FCF70FC7889D51C463A509E651079B4CB0A52F302EF806525DED8C35DAE
+ 3633110D3FB1CBBC5409071838122C70CA2ACF8A705BFD6DD8CBB11B19777F74
+ 96306CC2B8F2EE7B7BAAB2E27E7C859C705BD30A1704CA0D273667D3B23237FF
+ 85463E500CCA56194989B34BBDD1837918E4DE0DE6532240CBA144817029126C
+ 02A332B8B53522D0AB930E1142064C50CFAE1F29CF03496D6932B1F5EF6BD565
+ 6CE1F82E451E26110D5E6E335531274C8A3597B8D2FF903991B1F4361CA06D9A
+ 73E36A2AB23279814C0B06B6672634FFDBFA4707EA3A1AF1FBFC931360F385A4
+ BEF18A327E1983D0A5196179ED18B20939E2072705DADC55790AA73814B428C6
+ BF92381C559673E8F2E2D60CC7E2B9954AC5CB63211D4DAF26778323D6AC2823
+ 13AB4F4D708D77650A558BAC88F20DB666EE8A3C96E45A945E4028ED74BFB8CF
+ 5A00C9637ABC1136173C5374456D813A3BCF5EB02BDB23A115B4FA79CEEDBA8A
+ 10A70B969503FA78CA219BA159C31D1010DF11EE43072F5D21B400A264CA0DB1
+ 2EF220E16B082A28D091ED3E680FCBD1942F51C9A55381CCEAEA6D27E45FBFEF
+ D530CD8224FEAC2CDA1032A7C59D4F1EA05FE365181C538D8F8979BDC8DA51CC
+ FB6757B33FAF9CE04E264589C35DFDDD984322D600D27A72796B248EEEA1855A
+ BA1DB8C2B86D5F6F8B2CDD165CDB488F2D288C7BC3328F8870F6C86167C7487B
+ EC6F19AFE52F0023A1213DDAB80600195EA3F4FA239CDDDDCE6D3D7F8E17E162
+ BC46D5BE4C4A3B805E4EE1E58DD3DE3B2247142A3AD83E89ED026D3C00F9E7A9
+ 2C474C16B1A06B2EBA4DE5D73A30888E9ACD243CA64ADC10E4605FEE516BCCA8
+ 120C673A9765DD8B5C9121F4AD5C5C01C10012AC14DED09B9AC8392DCC637B09
+ B1F60B1E4AE93250342765DC3D3460CA11505FB991391333BF5D53CA2C6C8273
+ C7FA9586CB4FF627AD7A1E90C5D640328FA81094B88715FAADB5341410B99733
+ 941A1476973154223A9A1C7EC52C0E9EF15D0097283A872EF099059D6148A329
+ 1CFAE4C54B0BFB0E2F1A30EBDE413DC32EEBE6F4EBA0B95B594B5FEA476D974C
+ 81ADA28A6C028FA030A6C996AAE57091BB677EDB1632E18D387664519E7206BC
+ 135E868D08258FFE92C9257937391EA352C8E873AB3BA8C6D5012EB804C10A54
+ 75625A81C37C416ED9CA396F2949A1682FADC0C4BF387C0DE23DF9DE5656422E
+ 1AF7FC5A32ED1E98C0BEF1F36893A1F5E034FD3364CEA4C028CEA680B60ED6AD
+ B071118DB3A1CC45F5911FBAE89886F178FEEF32B35B3FC3F4087F30D37109B7
+ 6CCCB2A49C45399716C6F946560A012A7338C05EC53B689898347F629690DD2F
+ 86966C0F75132C5DCC523CE1BC9C602D321D3D4760051A7EB4CDBFBFE6EBDCD5
+ 4E78E60A06CF7E40081FECDF733D13496395471B7D816B26370F7E33AAC810D3
+ A97987568FF5F9F50EE120D7592D73722FE6B41B0EE3AE63BA8B2DCA79EB958E
+ 94C4E865E5BE8488A3D573518A33C4E82E0172829ABCE33D419088D6CA640E12
+ EB8A51AB8B961A8173709F5E1758156E30B8C39760189D5D7F8274F6E86C9A23
+ D94B0A530C7BFCCF4D9F2DA5994A2FD6243CF4D9B4F3E7D2CA62E8A1EA9DED63
+ 3E8FE660B1294BC2A459F76B09095176B9E491DBB550960F71672EDD96B15D2C
+ A0A587D4C7E92166B429D0A8C6229AE96D06336A03AE37B0A2CC34AADB6B021B
+ 7CF3827F7D723107FE73569FAA8C462F41E46CE51DEE7270696F962B8CB86A16
+ 4641A8183925226EBFA22B5DAFC41C47B9778A081F073C1BA73CA7433F7547BF
+ 9CCB1DB122D34EEB662C25F316C243A27EA92EA242DFB53C9D23ADA723E3A743
+ BDE5CBC4F8A435808A07D89A9675928C234E0736769546B32EA04C37F44E53E6
+ 62C9BBCBBB23CB4FE8EE9E0C2B8867CC971D0EC239B69E838326171B68B83CE2
+ 09853A2F4AA902D623ED0D54BE11F7BBFF10154C710FEC1238DFFAE3B218EFB8
+ 3CE44C984A2639E08F3FB8E5A71528981A54430FB7588E57B518C1BBC5E3B577
+ E7AB40942014D4D478B5481E1A5FB2F0234FB0A36DE3D9CD68BADDF920F747EC
+ 9937A13E07BDCCE92320AF66DBA607BEA7A2994F3049CF0084AED46FA70D7B25
+ B1167B7DB3CAB590F0523176DF62E27760FF82526E30259EB84407D2CE97EBD3
+ 3773CD769667CA9B821C196079D838FA774286581D25938DB9F244E25AD6C929
+ FF4EE690F619F7EB2F5E3AC11913C1DB4DD0400A71A2B85444E2A3141B7D7B4F
+ F18276A09A13BE024927B5D47CE9E86002F44125799CEA34900398C1FABAB852
+ 78E07B32CADC94347B0352956DBC7F6B46CCC98957F3987A569260D3DEC0D0E4
+ 16B76C486E46ACEC2F4C7DACFD9053E326A9FAF84767A0AC72FBFE75272CB327
+ C10438B348A7016245578B8201B028119354FD9B657B1A5C74D40B185A73CD80
+ 1DE97A5C4A8DE3534B30C48E2B8BEA8FD0872D14CD94081A7FBB6C65840E09AD
+ BDA68E73144723FA932ADD3DF0CFA0EE48A55D67BAD2A8A7574205136E967C1E
+ D5C0D1CDF70E4AC8D4990282D7EF6F0DB7A1ED1C9C40AFB1683B401FD36D338B
+ 551CBC9ACD68D4E2DBB5B9CEADC1B98488583846DBCD3F0CD9ADCDC7277AB36A
+ 76AFD667A1FFE36C7D24FDFA5B65DEB7F8D6CF86AC7AF09373A80E11B7EFABEB
+ DE982C2C3C7B881EF99A93B5FE4DB1956D1D4168D6BBD699DC7E7DFD506E67F0
+ 6044F5879BA2713548E351C4122442DED82E7AB833C85A080D6840276714FA73
+ B9D02BE0841A11A84BC3ACDF68114221C9D12A1A3A54346E660341063EA2CA4B
+ FA94FE38EF63DCC489685C5E7A0F8E9D4996873B1F9FD46CDEC5508266D96B88
+ 5CA89ED265C8D1EBBBD8DBFAA9298C9C0CF22CA9C0F81D0559FAC19DCFB74066
+ B60FF2322EC937B9E4FB0CA08F0140414CDEDC8941C30ED2D187134817F7AC3C
+ 0C1FAA40577C72D6B03DB4E18B71E0E4476DE7F7AEB07B5AC6986925960ADC70
+ 6D239188AC897D520CC1FE5FD3688E25412FDC6243F1FF556B5EA305F3CD58E7
+ 86FDF5AF94E4DBC66A027561BD6B2C0288309BA79B526A906DE7F3F0C0B4E1EC
+ A858CA03464CB87F7133B0BE5C01FE109A674B502249395731AF92F652ADC26A
+ 1455A976BD1E8AA64800296D5D0B07C4D52AC0A23F3EA9C4641B5BD8A683E8FF
+ 1C81264E3B467870AEC5D713151DA78839B07EC89D5CACC1067C46FA48AC4D0E
+ 63FABEDA0419C414EB02ADED0E52DA2532BE32E9E1CFE952D1A612F47BEF5540
+ 9693A9FEDF83DCDD7218535E137640F84C791ED614CEDF42ABC7D6016553BF6D
+ 5E2F99292530E596BD2F55E4129F107F87FC20BA91B184C712E605A21B935941
+ B871C6238F59EA6DA6E7E46F83E6AF0DB80EE40FFB79CB913A49C1AAE1B3DA00
+ 95DCDB8FEA3520C07890E2B6AEC8773356F8962E24CB3FAC32D1AB629C381385
+ 52400EC88A7BF3828656530C5F3EEABCDC6D85A11E0C22F1E032AC8C1DEFF6AE
+ 1E59F608ABEBE43383FC0694811BBF8322895D3AA6774B47E4E26A17A962B472
+ 906026A3D5F50244C5B20409F8A3CB58F5DF67D0110BBA3963A0372F6587DDB1
+ C186AB1FF8F729F735F3845D7AFB4C468DF332EEA9DF19CBE697A8361FD363B0
+ FEFF11CE404CF0D67C68B65FA1F1AD821CD1E9F98279F8C9085AE5E478A131E1
+ 0DB693A309A0DCAC4041BAD86D97DAC20678707AE2275F4A29DE1DAFF86C4717
+ D144B463C9E268B592E6B2CECE28583449BC132871597F9BE96272718C252A3E
+ 0C57C9ED122941EF49AD4434F8FE54F41378E6351914567D12166A3FC263E0F9
+ 961E3D957C104029688D2060A14A2DC09839262F66602D68331A4CEE3429D65A
+ A94AB3C16FA91035C1D335F55B811422DEC344241F1173F3D5C8FE15166D3A05
+ 45407B6D5295BDA1263B9A1B88A673BEA4F5181F750B267C086795FA39D7AC90
+ A8D8F436DE4963E7A46E3D104A7E5E671D84FEFF27F2C41B0805CC25860ACBAA
+ 9A477D4665D9D1B5EC8C63876DD44719F88B9923A16BB440C7B778E18F9B8221
+ E9848DC546794FE149E77996EF8DD590D7F944A0273DA1312359E3DA97AE1202
+ 1066BCA9EA51A27539CCCFDFDC8C3F21E3A20E78D4E0DD90EB0834759206D97C
+ 98AEF536F0D338D18DC34ACA62D60F7AEBDC8F4EECBD4C5A277B20D626A535D1
+ C09108606EBAE88C401DDCFE55F33F2763C1126EBC76FAD5446869384F81CC6E
+ 60B100FA2FE9472F82A54DEE082BDED1259EAAB07E046D8EA8523FB40C0EFD00
+ 805E1276160D852DD02A86A8E283B4F72FC281EB3EAB75AB2E92DEFAFFF0ED88
+ 841C65F5D178F816BFE55A167544C738892E53DD326E58C4560B87BAFC2981FE
+ 5C52EA2721B8CEFDD7604A7BFEE597917A248F5C77B9C8B2BFC11401868D7B9B
+ A921D2CB8BE8418A4C378B4E6CA59060A1F80F450D5CFB7A966D925B752434DF
+ C7784B70237750E39CCC1B7593DF9C6CF539A3626A0BFB692E32E087DDE8EAC3
+ E5B4B76AD447CD25880029399527AE8B1C3E22652247612FF58B2B4D48031158
+ 1837453A4E48F8AD90ECDA7BF4F77355FAA5460A00D9237D06DDBCA1C52A51D3
+ 54A314C17045FD467D04A7BC862E5B273EC19A746D93B7FF7AECDEBA990C9ECC
+ 6F0FF9F20A07BA2DD064A9CA3568833C446C9192D0381D53B3551A96E5C22545
+ 3CA65B378DFAD18930188B3B4EF05AB53533CAF28B34019BC78804DEDE3E074B
+ EFBBA85F80AAD189059BE1F3AE40206420B826A7B54D1B7481823E117589229D
+ 25185A9C97590256E39BB59CB572DD95795EF674D18336EE2E8F07589D174CE3
+ F16E1CEEB2EB4216747B23411C19E992BFCD7966979A82F4C6732BA7CFC6CB68
+ 38AA435F7C9E6EDDE025E401A0DD4293908CE2A986A23341D03A3EDCE99541A7
+ 5CE4F9239CA9E926B0BB188DBD84EA27AF7AB10BB00B178E9E8DC46D57061A0B
+ 992ECE5CBD3988C5923E557F1D7150DE7398CA8295A16121C2232A5A1231E961
+ 6C6456382E0C70AF511D612D3D35E5C129BF94F1D4C5707283BCE62C3CEC2D01
+ E9223A08EF572B6867EFC4E3C92E68CE4BBD9BE0AD593DD7BB38852D4C14B6F0
+ 810C405F9E76EFE9BDA28B716974D4D1268D554B25364607044A8BB5A76C0239
+ 7C65645A43A8AA9DD526C0E72EFFFD7AEDF50A4482ED2BFE1C8AD86A03043451
+ E7D31FC9
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMSY10
+ %!PS-AdobeFont-1.1: CMSY10 1.0
+ %%CreationDate: 1991 Aug 15 07:20:57
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMSY10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -14.035 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMSY10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 0 /minus put
+ dup 2 /multiply put
+ dup 3 /asteriskmath put
+ dup 15 /bullet put
+ dup 49 /infinity put
+ dup 50 /element put
+ dup 51 /owner put
+ dup 57 /existential put
+ dup 102 /braceleft put
+ dup 103 /braceright put
+ dup 106 /bar put
+ readonly def
+ /FontBBox{-29 -960 1116 775}readonly def
+ /UniqueID 5000820 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052F09F9C8ADE9D907C058B87E9B6964
+ 7D53359E51216774A4EAA1E2B58EC3176BD1184A633B951372B4198D4E8C5EF4
+ A213ACB58AA0A658908035BF2ED8531779838A960DFE2B27EA49C37156989C85
+ E21B3ABF72E39A89232CD9F4237FC80C9E64E8425AA3BEF7DED60B122A52922A
+ 221A37D9A807DD01161779DDE7D31FF2B87F97C73D63EECDDA4C49501773468A
+ 27D1663E0B62F461F6E40A5D6676D1D12B51E641C1D4E8E2771864FC104F8CBF
+ 5B78EC1D88228725F1C453A678F58A7E1B7BD7CA700717D288EB8DA1F57C4F09
+ 0ABF1D42C5DDD0C384C7E22F8F8047BE1D4C1CC8E33368FB1AC82B4E96146730
+ DE3302B2E6B819CB6AE455B1AF3187FFE8071AA57EF8A6616B9CB7941D44EC7A
+ 71A7BB3DF755178D7D2E4BB69859EFA4BBC30BD6BB1531133FD4D9438FF99F09
+ 4ECC068A324D75B5F696B8688EEB2F17E5ED34CCD6D047A4E3806D000C199D7C
+ 515DB70A8D4F6146FE068DC1E5DE8BC57034F4D9A2152A6B38BAEF33DC201A05
+ C8314401D1EF6AB12A61389ACC214E61AACCA6B38D58A0B9E1FB847902E51AFB
+ CE62D86EE1D33F2FD53457E35DA66C98A14FE772D8C5FDAB8D1215A83F1A4F3C
+ 085A019B6D8F97B865603CBBB7E8FB7C04DAF888BCEC95A9AB6C3F03616075D4
+ DD1978C92FE6D1ABC779157A2E034FDB9A988D9F4C72AD97F1552291BB31A013
+ E8F577B52CF63A3190C5B6AB270E4C64222E8180D2F6CF23AC859D280C4D3DA4
+ D63A700F84907F61AE44834946E07BB4D8665A72D14C29D2A1DB8C0C7B153C8F
+ E2796460A695A3833A4703AB3BF5B456E51CC0902E64A263103F684343398DB6
+ 7297F4444B30D2C3BA5E8A551D0D1008C83E3DB18F37DCEA196293B34C04638D
+ F7E368753D24814A01CB5B0AFB85C35A3509619CB99274A3DA0FD4AF33B54779
+ D6ECB9AE98244B24CE6B8FFAF5CC6E187D10D3B6B0E93744DB6FC2C708D62C1E
+ 277BD48A6A9774DDC86845E59382BB66EBBBFB57B9AD203665C553F43CFD65D8
+ F8AEA7217C3FCF0244C21E8BDD9A2ABBB46928871B22CF3F84A12B2B3DFC8E2B
+ 7180634ED8FBBA144C6272498DF43F8EBF2145988E282A14E4CB76CD0682DE51
+ D0AE70167026B6AF59E845AE09F4A078911F58AC509F19302D2759B39A88D792
+ CC08E8559AB5A16064EA6B4D5F8094CA0C90DCD8B0F948AC5A0C4D87E0CC9370
+ 7A6F770E544417C65F7B8169B11B6CF716E2EFB242368D46793869652D43A02D
+ E3B64341F15BF50A911A4EC0CAF00220730EE2CD3928116C3475810AD80C6339
+ 7E9285B4FD17D2A174B13A9BCB4BFCB5BBBEA2653E375FFEBB934F6E3FE9AC1B
+ 8D10A259FEBBB7EEF976AC7D5498C873451A5E910DBCB28A2C4CD55912DA59D1
+ 10A10FCC65B839F2AA4A8757F0CEC6833B8D32B3C80F29945026EA9832264B38
+ 0D736382C529905D6BB29C259A810F77461692A8F1094902D6B60E54813A63D4
+ 3EFCC189843688ACB3F33817658D2A41470C7E11205046BFFB5E8A2FB5A0914D
+ 11113B42C94AF07B77F99CE86F1E26F4310265D8E78FB13AC82978B5D6877671
+ C57DC308E76E5BE7CC7F3F4DCAEA0523C9769F53CCEFA654BE5E9F71CC9E85BA
+ 3183C9B1CFC3A067354BE526A582C86C332FA78D23177DDF78966E84212406BF
+ B1DCD27DCEB8117C4224E406523F0F4E7CFE8087F2B882C435E9607AD27C2301
+ B2233D57BFC6EFE8571998547F6DCD581107C575FF01E65F580FA35C40109874
+ BBF4DB87AF68C2235512BF0BE33CC01A8BCDD984B5E2872507101EB6415CAD2E
+ 2408DF751829807BF86EE158CDBE142D524127A2587CA839610551A283F1F071
+ 5ED1C887D81271ED5EAC7805DC7B019CAC6FB7006A5B6260DBD0A9D1631CB832
+ BF17D529B243AC9411D648F1644311CECDDFDD9ED595464EDDAA85AC54DFE0C7
+ 47F6237BB796AA7C31C24F15204D60DA3AED5ECE5F5BD4B6A469915D49F5ADF6
+ 98DFEFACB9A19161075BB4AFA29543BE655E3C2495A7A9FB8F4A1F711CF17806
+ 98C0FD0123C083B17E2251A3B9FE68A29972C219B53BFB2D2383ED16A27246A3
+ A51137B63EE962BF19DA85289F3BCC92C86C1D6299518E3FE5E90E7C9CE50CD0
+ 0A3DD20D804C52FAF752FA13AA59AD08257E45CBFBBD3AD37740D8311F8FEFA6
+ 2C3B29A7DAFAD4D52BD178DFD60597E69B32EB0C75C83F425B88BE0C7912CDD3
+ C317E092835346B1BA2821584DF3624522704D175EAA3BCED055F64CCB940ABA
+ EA96C522A3EA1781BF78373A1E69FB5D6BBA5D4366150C00A2A2FE1C073290F4
+ D4DF016F3C522E9226486510A46CBB98E29AED0923266EAC269F28A0DEC140B7
+ CAF4144830424786CA95C1B40090540ABA5FD9DF19B9434689B7DA22E5DC707A
+ D479BCEBA288ADBF8248E3F996F7FBD5C1F08F987E0873553519542AB673F833
+ 5549CF5088379C8099D76F939E0CDA999412164BE6A63C520298251BFDE373F0
+ 28EBB96E8B2EDB39C18689EFED556A94DB7707839390B94CD8DBDA5E447F7893
+ 48348D84DD7C2BD86AF5C286A4D732FA0E906902309F96599481A2C70E9DAB69
+ 215D5747D161308383407FB4F933D20AF7AE99935B94BF8E82F844171596ECA8
+ 4C8F71F01BFB303FD7DDA96BBBA1A77AA5D2F02C2A97EFB09A4821C89A389921
+ F43C18E3CBD241DEE504CC29A20C9696E1BC1FEDED7B49AF3E4B9F6F643217D6
+ 91151C3D689B8D5E1A4DAD2065608BB269DC7A0E3732C07B72058F61797F42E1
+ D570DB8F9D9C52B2DD1294388717E7C9C07DD30100C01BCE6B8EC91CC8564F2F
+ 7A3F6A9217EA76A1BF495839F2FAD261E30979EE603A06869D26C33C0814B8F0
+ FAED7F7388762293C57CA874326E6D1166D9F6F05FF0F4C151DA883FC4C10880
+ A56DF2F3AE5A4900D824C2D3D9A3EB
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMR9
+ %!PS-AdobeFont-1.1: CMR9 1.0
+ %%CreationDate: 1991 Aug 20 16:39:59
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMR9) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMR9 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 11 /ff put
+ dup 12 /fi put
+ dup 13 /fl put
+ dup 14 /ffi put
+ dup 33 /exclam put
+ dup 35 /numbersign put
+ dup 37 /percent put
+ dup 38 /ampersand put
+ dup 39 /quoteright put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 42 /asterisk put
+ dup 43 /plus put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 47 /slash put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 59 /semicolon put
+ dup 60 /exclamdown put
+ dup 61 /equal put
+ dup 62 /questiondown put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 91 /bracketleft put
+ dup 93 /bracketright put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ dup 123 /endash put
+ readonly def
+ /FontBBox{-39 -250 1036 750}readonly def
+ /UniqueID 5000792 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5CF7158F1163BC1F3352E22A1452E73FECA8A4
+ 87100FB1FFC4C8AF409B2067537220E605DA0852CA49839E1386AF9D7A1A455F
+ D1F017CE45884D76EF2CB9BC5821FD25365DDEA6E45F332B5F68A44AD8A530F0
+ 92A36FADB679CF58BAFDD3E51DFDD314B91A605515D729EE20C42505FD4E0835
+ 3C9D365B14C003BC6DD352F0228A8C161F172D2551CD1C67CD0B1B21DED53203
+ 046FAFF9B1129167921DD82C5964F9DDDFE0D2686875BD075FC81831A941F20E
+ C5CD90040A092E559F6D1D3B0E9BB71733595AE0EA6093F986377A96060BF12A
+ A1B525CD9FA741FE051DD54A32BECD55A868DD63119A4370F8322CCBEC889BC2
+ A723CB4015FC4AA90AE873EA14DE13382CA9CF0D8DFB65F0ABEDFD9A64BB3F4D
+ 731E2E1C9A1789228FF44116230A70C339C9819676022AB31B5C9C589AE9094B
+ 09882051AD4637C1710D93E8DD117B4E7B478493B91EA6306FDB3FA6D738AAB1
+ 49FBB21A00AC2A999C21445DE3177F21D8B6AAB33869C882613EA6B5EC56476B
+ 5634181ECBF03BFEDB57F079EACE3B334F6F384BDF9D70AEBD592C8ECF21378B
+ 54A8B5DBF7CB9282E16AA517E14843909339B5E7C55B038BF3BB493F3B884A1C
+ C25F9E8FB912CBE23199AD9D2C3E573727701BA301526C66C3617B9514D6F11F
+ 11930B1D97C17816C85B1BFD9B973A191B33CC3B391815AC46268691C741B2D4
+ 48A840F1128D9B2F9CF07D0709FE796B23A836417BF7B5B12D67F74453C82F5F
+ 25F7B30701D6F6D4F4DC623C0C27D6A6FBECC7312A3CD10932FC7C10851C3C52
+ 24B75DEA8A648B7F34F5711DB0E843C914E25663C510185BC37BDB7593C1C259
+ 21D8DDAD33982C336BF272BAB2F48E68217403FE9F54877B243614A87E64784D
+ 2796EE4179FBF96123D1BEE3EF89D682B427BA4F12A1318A57F18BE5DD903815
+ 261919C6C24454E652A8EE1835C79E7F020745D97E8B02D00A5A0C55D2E203B2
+ 9700C5B49CE6C2BA3FFC71FBF71B6FC07BE51E2D7B4F03A32F378384A0048C28
+ 56678D93C2D6B40C8A4735D90F9A89F8FCE00D2A293F25DA434D9F76B8C430C8
+ A4AA7F3685B27BE9496A9ECE956867064911DD00911EA779D39BE988F0D7E280
+ 66779E0ABEBC1EFE003E27DE90E4D532539F950D090C20224EB4EA99DA79D9FD
+ 70ECDF80358DE212F763B7D785BC3B773EE1BB62556EC6364E455EAE3675A6AD
+ 2558ADCDDFC587C975A88A7C6BEB0A90FF7390C55A9D188E43BD930BE70DF8DC
+ 39FF249D6095BCA09E1A875277C3FC5EDBDC08EC9F24AB595E912E8B0BD37D8E
+ 92BC43F4906825BC5F2FEFED5DE35E6D3A3759BE4A426FF9BFBABC9E94F1424F
+ 0B33FC0AAEADCA06EDEA7C637794D14CFFB305F68E7FA065B5AF368F46FF8B75
+ 0B7D29533E79039BAF886B40A0AF19A81F8B1B01C723BBCA8EF0609EBA9074EB
+ 6623FD116166AECA1B65E60334EFE16A266813E340BFD7B6BEE75B6AE4C21AB8
+ 05905F219E1EC73EDB25F4204ABBEE992898DB0819F21246809593EA7A5FB536
+ 17945BD87EF19AB13A4D99B1B69E192AB2D539429106BC5ACA9E5765ADF5F970
+ 99E92D36871EB7CEBE545D7785FF7870C55FFD323C9808683F053764D8DC3776
+ DAB3AF177DE930D7F3DD0AC9AE68277429A0FBC42661383EB7DAA046BEB4990C
+ 55B0914AA2800368B0EBBECB8C877D401A7C56838A8EB4246969ADB49625A621
+ 26925B64D5E01BEF1F72C58967ECFA1CD56D451FF332EAB844376F384433CF14
+ E63B9B95E16E675AE5F824C3A7D704E76C74191AE53F06E6768FDAA62AF4B52B
+ 90189B1F8D509B60ED2DC1B00153858E2F42265AF103AD71F7206CDFCAD5B161
+ 2208758E57CB85957593C99D462D3B36A793A0C3C7C3FCE57056FCAEF54C1B6A
+ BD8FC41C86946DFA0090580BA1D891B6EC22ED6AA8B595848662F8A3925CC018
+ 85BF4B17CB5C79B986E482DEFE81E46E8A283B3848F757B0BC89AF897888BBED
+ 24846E32BC0BFF6CB196D191CA07B8A7A09CC9D193223DD42AA7E61DDBD00918
+ 8CF40B3BCC6840374743E5BA51B744FDA7B06ED47AA56BD3CD3C53A7C9FAEDDC
+ 6DD058EA2EDA38291BEF0D6A664E60B4DA4D545F6A26D5AB7F0C0DB41337BF1A
+ 8CCF904D48EC4DFC31874F9AC64A6B4E58211B67977BE8D5A8CF76CD0862B5E9
+ 6C07FEBA0E5697280EF2C20A79ADE49AB9705942233DAD18203FAB33690759E1
+ 9415415EC4BEC897101173E557EE70AEE101CDB2CCA3B3B86862F8021F6091B7
+ 9D040671E55B37EE372A747FEC83302F745F9986AE0C16CD28CE9048D92C27AA
+ F35F6E1CEF28493BA1BE41ABEC00B7A7DFA191B9FCA55C0BFB350F5DFD227625
+ 8CBAE9ED338CB3C55C240616A2BB2B9D95211F26F1DF2649D3D2CFA42D4D229D
+ 776071FF1036DD92C9F5C85D4308FF705E39119FDC15D6186D6ABED1DF19CA03
+ 72B42983711B310422F0A38F7BF5947EC4ECFB789ABB78A6919D1AF60986D505
+ 7639C2A7B308A2D9B84EE021FE690EC3721471F911A648A97639AA7AB672FE2C
+ 796992ECF420325B32CC4162DBFDBCEB1521E8C292255569D6D25477F71F6261
+ 9569611D121CE26C7AEDEE7669A814D204BC76893EF552144629FC36AA78C9F5
+ 4AA825F1C1F63A6F5F2E9378B56C86AD215E72B3A6A32598B6C5D1882530C4C6
+ 80F846DD9DAA47EC38AC493F5265E03C08773084316391F9487A2FB633EF30F0
+ 6A00FD9C009968716FD52E20886A9C7B8088E0A4C19089FADF70E80AFAB888A3
+ 45D270AA8B3D118D5DC4B563377F840352A9A585F190795EF8949BB40F4A7742
+ 11366D8844B8AD24AA8715D1F456B30BEFA77E18B5311FD0360287B50D889671
+ 439E95C44A2D01C50223245FD17CB708B9E81BC83EE72500E40038E4D52C0E0A
+ 95D446E627BE993FB56FCEB81EC67BA4F8839D006EE89C08EF2042BB2A3EB377
+ 39EECDC1834A22BD8CD1A99718D9D4AB9A26A7F1192D3058550BDD9F4444E55D
+ A3BF6CA1C14ABC8AFF53CF92495A049786763F3AB0DD7F1845428EA14D978CCC
+ 2774A49BE2855385B223E2F5467375E006024330C46626E93ABB372575BC1B8B
+ EFF2D624024BF7580E6C1FE67271CFD1D31E0FCA84C053DBFAC3EC67C9399583
+ 1FEA74D7233A7ACD8A09BA4A2F7DBDE80BC2989C8677E3282091C81EB4531595
+ 9D954F0B740320CA598102F855F8D3D4B4282EA82AC436A91E9B87E9C466BE6F
+ BC2DA7A4C7BD0E748174A1FB77942714F8512A90BC17EF7EA16A63BB0EC728C5
+ 0BEB69391AED59B09ABDC126BAF56B47D03AB478D4DB62A4D8C73151B3CCE26C
+ 7BEE759C0129D7C33E3AF96C479F5CEC39D3B93E2EFAB3F14B1EC3F4259D77F2
+ 7CA3BBA5DC8A77A180B0B5A81217FF134331C013903768DE5A0BC1E063611390
+ C746FED664A369F6811F7F75123C41F855D086EFD8D3CCF5CD7B4C09774D0E91
+ 746C022664F3BC33B6C94FB7D6E9AB97D8B8B1F06BC5B82530D524AECFF891A1
+ ED5D1B7EA90210AE3FA25AF7D430C01EE062B033096616E4FBE44F8A2255BAA3
+ A09F761A15795CA68E50BE8B5F1137F1EB56B366E5D8EA346D48FFE4B22583AE
+ E6D36F59056BC053709FEF9D26839DC9E17D2BD65B6924CF0A787E0D1FC5683B
+ BEA714F01455FB046EF172EEB95965BC63F062020508B00A69F92499A686BF05
+ 299535C9BAC53A05218431F68C8892CC884E77C8353DD2159650D0A6EB1955FB
+ A2D848AFFCBBD23FB271F892E1E23E3F88AEBFD4D15915957C330213128A427F
+ B7A9E152348439144874F494260EFCC27B889365552451F6F9DEA9DFEA67F1C0
+ F192081D05602BA83C67D8D0DAEAB75735A6B14182BC0E408C6C5B05D0AF5566
+ 4595B8F9B95C9EA1A98852A649AAFF3838B2E28F1EC749E87494B8D583A7B426
+ FB115CB7725467513B5D20316CBC4AA04D87D83033E9245A0FC1FF9087206142
+ 68DE7B4FAB16DAE2357454B2DACEDB1AF7E6C0C5CB3D5932DD7CFCC66B0EE97C
+ 10F30FEA6E659D545D396ECD2BAD1482684B9245AD98666CC0BDC589993F3C1C
+ 2BB3D56C6D61B2D0D2351FD2A060B711E9691DA8B35281945B86EDA7213FAF5F
+ 593C7A6BC783E475A941FEA1C83DEE0C0C7E0C9CE0B7E6565909745264167C32
+ C7E6F17A342D85FB6D2EFE7506F8EA924865DBC8412A0D25C00F40A3BBC4C96D
+ D5BC6D30F7258829071DA7B0C1BE321B2CCB07124BD23AC65430908E732D46AE
+ 29DF99C6C923595D026D46B861EE576D63623A399D836168184E1DDF4FDB07D6
+ 0FF0E0F319BB8239579D1385B9E6D078DBAF3F5823B0B75F3B2B34C7047E1348
+ EDFDE4456431D4A8C05B9B69C895302F181385FBE913894A15FE767C41EE95A8
+ 236ABC961F3477EC03A58E593E6DC6EB300E63FE2A2D3E0C44ED41A564F38233
+ 972C0B6AD69F12B33C3DE236AB8FC9319BC99749FF804F96BC28A2333C98E6CC
+ FF4473683CC7DB43CD24AEE61DE8EB9D85B4C7477CB09A739CFF426FEC3B8F30
+ 876E296876242CFBE8BD9BC5E3F6B0130CBB3D4AA85ADF6D82C49403B7CB3077
+ 3E295AAF62392E22E1C1DB8D490A530F37A7D4D291B8D78BC0C9ABC63B2072B2
+ 04EE8178273BA417C695226C4D7C96126E207C4C208CF200B76D6E92CCC00AEB
+ 929EA7D35CB69C7E29859D8C32A57715EF6CD3F69902D70D6EB9955821784076
+ D9EC941E0F54023E0FA762262F1E86F10AADAC379581BBFB82A6ABB0A6A8884F
+ E3E3C5D66AC681A867CD559B7F92266F8D058CEB67D12F9D0765B06034E3D287
+ ED56196CA3BFB4AA5E22CFE17757777E6C706FA0677203D76149B7A63CBDD668
+ 36A0348CBB34CA0E037C09485BA40081A39264C8B62A6622F3E22699BD5F630C
+ 4857757CE6694027C9267106027B5E6F671DB827A9E9DBF0A5D35A10455C3568
+ A76813E15DDE9B03C3D03198DB46B65F3CE82E4C403BF09E1458CB32A6533416
+ D23EA892F492B97A3CA28A9D72BABF8BF9A0A5F83F67F03241D685F974EF62FD
+ 1113F707D7C7457EF1BA346D0DE17360141F7A21B3DB5F55022107A3972F4DC6
+ 3164AE94C1A8D3A0B52533682D2D851FA44B66F4AE1A418BB3B5379AEF227DDC
+ 770297F3CB88EEA64CB7BE56AC0ECBC11CE5A7DC283A5EB09ABF7EAF5D5B7820
+ 9DF11D216A1FE3157123CD2D3F2BB53BC96F39F27CD04C530C566B203B65500E
+ CD0CA3124C03AB2BEFDD992A405313902D6390B595F0C76A0CA841F7EC55DA1C
+ 3449FA5B0BF3617F8D412B16D2D9787C98B6E71A50C78AE2B2FCAB6602E8E7C2
+ 9669261F894E0C4626B7153C5BB90292D4FB8EB21B813B3B61CD565BCFF5FDD4
+ AC1B0184D240269BC7B8DA5D3EB40AD41C4E7E30B25A817405B9C09E0FBD41A2
+ DFC6DC6E3B8D2B7017EE09EE96A0F875FC981040BA10D9081F80C257336EA22A
+ C3B9BA4EEEBEA26490028EADCFE79E3F04C694929CB056AF6DD134347F11AEB8
+ 3D75E58ADF383ED4D78EB90C6CFF5CCDBED3476C32321947E826EC381E30453E
+ B3F50E80E87B92DA84D9E4CC9C7669F7DD6BCD0CABD1BC541EBCDE52C8C519C8
+ 98BCD9ABD443133D8EAE7F7BF46DC7F37D469382D86BF1E3D34EE10A7B833DF9
+ C590EDB8EE67AFA0F3D7DB484AC5B0997458BE03A096344B4E67258187378A35
+ 66F1A72D99B7DD8381014D4E57E70C0BC64BB0C5E9CC680D8149F181A22DE96A
+ F190AC0EB50413DBF14DA4310149755D28C6D6120C5F8E8398B5D310341C4E51
+ 094EC9500093D0C6AF06AAB3471346F495EB7EDE376349DFED5D5D422DE17E64
+ 073EEEE6D97AC333637ED8E415E84E068A1C978D886282FECA8B46AC16F2ED31
+ 5506B1FA4093F096DA445EBABAC5A0A275DCC3DA57C5C01342EC1A6A425E9F0F
+ 9AA03FDD54AEA65DDCAE84D5C126DF6B75B8756F82937F39D59D7B497C7E0520
+ 124E458340282D884FDE0721B4EAB528D327A64D50F40B00353FD4F28FF0E443
+ 312773ED7ED9775CA04EB0C32851AC896244D957FAD697DADF5B9E33BD8783E7
+ 8D1236AD4C418D4F5ED84F438528ACD04DE0772A0BA4552D4532C5F230841BB4
+ 891E00A31B01202EA22AD3F8A33A86747B68C27B5F323C1A2C49A8D7BF2A2588
+ 903A7C6238555A33BFEE5E3C49EC6913275FB4A1E66AF1685205E95E331AD405
+ 85C0AB47C11E4A58E5FED5BBAFC8C5A6DF71209A59A013A701DEB0C405531120
+ 80E6DA7CBCEEF3F532DC6ABCC57A8E8F8638DEE227806134752342F2AAF1A47F
+ ABE7CC2C54583D0038CC60B90176BBC735334B003E5D1C1B90C3D152146C5547
+ 13A224A641465E503A56CB5AEB282F07D619691DD91F08D43BD25E08538B7EDC
+ FF346828F4AAC24F4269E0E61B50AE002E1CBDE04496D3DC271C2D6BAAA22D98
+ 4107D81C0138D7AEC2488E19A6644E8217E244042FD9756EA8BA148B7E6611EE
+ C82148F4185271B6819EAE14EE739C25DEE9F3C861CBF3C1DC5CB3283E012F07
+ 63296BE538597E7C5B92C173EE8BF3AECC80971BF037ADDB08E24A9977C0492D
+ 9D45B1D8388D8CF2810A8E36437C5E88AC10E70C3D9314B2836978422FE7BD75
+ 67153E10227A912599AA56B7C0C34B34967234EF98DB8A1913ADC802402A9D63
+ 577E7F78803B58D6308C6A8E2D0A8F27F5D98410AFC20C82CB5676FD3DED17AE
+ E6F35BCB91E4AB8CB5C314FDD8576894085CC3D831E7CD1C3BD73C96F6CB4FCE
+ 520A88872AE87D6DCB47ADC50D9C9C3D0E5888D8AB7315546DD81311894D55CE
+ B7302F79E8A2583A0E5F235B4529882D444AF767B69E43ECDA3BB8880712F6AB
+ F4F26690373EEDDA46D403AFDB4B4DB00BEBAB1FD84CB0893ABE6304894AFB90
+ 5ADE2560A17B0E4AFB93F4200EF9B420F7FD03B9AECB6EBEF07D0BE29C4B2C9F
+ AC0E4504A2858D70EC731DD02ACAB76452C49BC042BE89F6567DDDEA8FDF48BB
+ 5842F508989C4D244DBD68C8149C90D8AD12B18BE8AE7BDC6C21100A761DA803
+ 434D1ABE5850EF75DDE9DAEE8CE5092061342A378020529EFFF72D2EAB281C3B
+ A7B735FEA9AF9B557927037F331752F77AA47CDAC247E02D5B7FBB637190B7DD
+ DB276D783B053C3006A453DF6E2B6EF3DDB13FE167F5F628B9316EF9F6B66663
+ 7FE94825F17121161A7B07FD4E240CECBEB3C6E176516AA73E63F0CDE603C6C2
+ 610566EA9B0A79C3E19BF73ABBDA447ACCA133ECB6AC3EA42D15F9E034FEB199
+ 487672602F981EE5BCBE0EB967B2051ECA74F4936A9D430F0D9698206FCCA4B0
+ 0BBF657DDF5CAB6B761AA79FEFEEDD2DB2FC233B9382BEA2AB939BD461B04F8A
+ 41B919CAE5126353E1835C71EA699176B928A4028D622D08235680B199833D76
+ C9F34A12120B680A13717648F935037B874245FC89A26FEFEBE0D0AD9211525F
+ D74B353CC397359E2903CDD5428F38F01594239427709291D9F10CD31ADA0EB1
+ 4E220AA15DC11A2F8C82C0AF9FC38008C0E39600A9D6E884548C97F573DB10F5
+ 2DC652F17F9A326259487165CAF42A326B02C770FD5A0D4903DF8B656778F25F
+ 40C7F4F2018C751310DFE5721B09C83DB79EAB0E1B672148963928F19299A90F
+ 60CFB7D7E0B074641B5B761FA829250490212EBF84CFFEFBA07695F853A9669E
+ 4D5E0DCEFBA670BB18ADD7FAD1C5F598424D6F2325782501BCECFCCF3F82B41D
+ BFFA198E843A9FFE5CD92FA917C12AA8DA1257D38FE96DFB9B34AEBA2C22FF43
+ 4B3E49272A6C622AF38BEDB263A5DF0403C6A4475C5AB96693BEF18563DA9D03
+ 82A2F00304C8229E9605A384FE36B111B7E45C5574C6B669424F89783C303046
+ B6CF521FDFC2570D24E0AA4B580B4CC9AD3A44BE01BD956CD035E9B92440B4B0
+ 50FBB5C11699E27CED2C31A58C444AF1547203A5002498681B1A6277B8B3F3A5
+ 66CEF5560128A726ACCCE3BE948EBB175564D08ED655D5D99B148FAF3854E045
+ BA4664956CFA4796D943A94ED399B242FCA0EA66D37D69F0A53E1066DAB5C762
+ 155E30E148DE01C1CED95EC91D6F7E8319E311143162156131F1333C1C5A9E80
+ 837B20BE9FAF968C65848D7584EF15F1E343C16C9BD99EDE07DD34B805E597DA
+ 977C52AB2C0965691DC1AB593538758A19159FAD888496275D6A28125D1BC0CB
+ 0F9A541DB523DE5F43C31FD71EE595B78A920F59D7D9FBE733D07C19F40C8E69
+ 52FD99EA44EB0036ACDD104AA8D0AD6DFD4E31F4CFD4112D2581103CB6FD08E6
+ 7AD27068BECB2E52A6528AD10C33490FA68392943F3D855F81E2CFD55014AFE7
+ 5EC91F7E2D97B861C3E11EB11EDB706437590DE0D5D3E2C6547D968E83A43B56
+ 052558F0472C028C859B29E68F080CFACA255A3072ED254B75212D5CF681DD31
+ ED5904F78918FEF5799D5E9E66891D780EB89486FA0D8BE832CA79E0D0E2F488
+ F5E9EFC9CD0EC633C944FB38DBB0AEE2586EA2D92D4F05EE0913BE0C20DE8CCC
+ 53D3965D2512E3E591DDB37B553A2C4F9308A2B30BA90424949F71164E34038E
+ 64B27E2BAE4ABBCA606F3BD2256A4CD0D9F2B9C9642F02483127E304CF3DCD8F
+ F6A8C683A9B33E4F3867C73AB9F3EB4C03C81B12FC0038169F1DBC40004F5A12
+ 3CDD5E6DF509E14ED475E2BBB020BBBD386C3574B025C95CC225F70FC1074D3F
+ 90F873D0FF4AFAC36D223B2B9EA9BD46A44297D19D783C6DD6E01E510446E83A
+ BFB19D7257996D98EFE8F75A7F04417DB22A3DD31AE923B8C4C4F8166AEFB721
+ EF0CD6CEC8E98DAD5FB98407E44C92A98C5E1D1D150F8630D9B3D43BB5084011
+ 55D714B191A30533A38132236A405F9DD592F94740B4B302F0D3F1ED9F0A30C4
+ 0C463E99ECDC4A45AC687938A865AA1CDD227C5DF32E1BE4E4F33B1B1225B167
+ 53E347680F4E51205C491E76044CC1642AF6599916DACCDF274B797ECE9B0FEC
+ 678097E236ABAB4B1663C645079FD56D0007C4A35ACDED5D27C13573974BDA92
+ 754A270DD21DD6E47D18B7A3124CAFCD179051A259F7B52563105505548D59BE
+ C900B61C23DC9ECC05EF51FDD3ACC84043854FB1DAA6102FB9150E7408C976BF
+ AA6507A3DC66A96EACFD6CDEB78098C1F5663FCCE08EE6500C458EFF69397DFB
+ 489EBFB3FB437615E85DF3001C9C13CAC51138CF6338A517C99CF51C5B0A6421
+ D98FB372B444FD14030BBF02E7D6D9B15CE00B91B980797CC2278B48C91E6AFB
+ 0AD2AEE6DFE2E58BD0C8CE38EEF79A1A634C4FBA7144E58F6D40A1B8DFA92F8C
+ 8C510FDE190589B26EAD47541ACC29550CF5287E0D59B51E7C242EBD33B71A35
+ 3FD005A3B6765EF4D4583B0F8FCA6265B5B70FFFEF9DBB935BF33F1183A025B0
+ 9FF856F5406CF8011BF4ACB28FC2E441F8A1D822372F14A132B3B63188810276
+ 7A190624498065D0B03E1737C4B7346B803B05EE966D4520257E67AF4A1264C3
+ 4E7B43D9ED682699FC5C12A3DE0D059D901994E4581D2BD7A345A6FFF5D2DA29
+ 7134FC83E148DDAC07F9E8CEC8A03404EEB535C5EA38DDBA7F2A1A94CD162562
+ 6AE8D4B119C74B5EDEC56E0BFD0AA0454137B6BEBA7E2A97FFF9313D44AB4D35
+ 8A11AA8123EBBEF84EDC879E2D998068E4F3F0AFB7126C429A67681A38988ABF
+ 4C882BC7624732328BE603ABFB905FA26731B19F320CE58AB62C36D51A716BB2
+ 4F9BB5F7742B95BF80811495FD50FC1F0D28A9A8D41322B8D730E3790A01C7BE
+ 032C0FF77BE2CE6552F20A9F3F22A6031E0D8B6C992DA12A04FD1A287D349FC7
+ 2DFE3A5B692BDB5FA7C0F0E8A12B43793BF4F4DD43992D6E369252F00707FC50
+ 84C7568B1B01CD2FE50A8FFE4285DD15B28ED8A13625E8C4EA890AA2CEE411E6
+ 2E2F9FEEE1A51B623A4E647B912302BC5D4BF0AAC78D595B54CADD536ED5224D
+ 4AF093892626C9FA61DB707068BCC95599B737DB8D4099219AE90E6D10D26A01
+ 837E00F761BA0577F6FCF741A1E2D2BAA736BC90BD60B09CEF12485D91E25EE2
+ 1B560B118E8DA2C7544D84FC8AEA603BF93F57BFF26244F0AF3424756E807B70
+ 2E30FA89FFEC9F53C0111DC6576221FE5BABFFBBA1A1AA0D7077DF1BF3338124
+ 48DF757C6E87A97353D2DAC8CDC1C4E1D83FC452A1E1BF73B7E667700D76D57C
+ 0D29A3F57F236FC3478483D5D56CE3AA823CD729ACCEEC7EB76D617BCB607106
+ 71F2DEC13FE0514CA68B961827EF1AF54B4F33006D5FF621F77D73287FF73B39
+ 9030D03B5AB07FB8D90BBF313FBDA182CF8F18D81BBF1E145B6710B5442D61E1
+ F9734E401EFDAAB07BEDA3471E786BBF950ABA9F24AFF1E694D48735F5DB29CA
+ 41D2BE1FDDB63AC2184372B96BC43D45EFFC0AD723F0676206FB59FF7593591F
+ CDFED81B3FC5668E478D89E3B29AA120B9D96B694B52BC038A7CD84D2D924AAE
+ D5CAD357B2E7F5FAA125059D3244E3D103A58A7CCD4F686E2520EE6254A25BDE
+ F55AA81A45D84802764DAAB2A0A6E2CE25FF4ABC7FBCF88C801E424894BB92E8
+ D69100D42BFE77B3360CCCFC39801327DA4725E00AEFEFB2E42F788A08048CEB
+ B2CE552AA589E2953C2048814B123B50CD8448A6E604AE7E18E2C97782BF559E
+ 6E30138CA9C209C9863C01D928049591529625A203F6FC6A4489A5AEFA25A30E
+ 9DD3E015799D4EA18C5FF57E9E514982010BD91F6EF63CB36CA7E43C6F0F773A
+ 177B9E9832F56327ED6AB92BBC2FE14191070AF91915C2416C2A316EA937F06F
+ E10B7C504AA05078A0431F2FCCA899A4C5EC8FE4A902094B5ECFF36744CA26F0
+ 5FCFD761D801A73DA2E1D09A1936B22E76EC1175D34939E77725A57AA9B54341
+ C164D5254A6C95E3235F72C2DA9C24918C69535848EC55F0CD08655334AAAA71
+ 4FB5BEF797D522758F9C4D7158232091B417754F8A6A8488012EC493335C7A90
+ 8B6D2B3262830AE215DE43C8C4A474ECDC73DE41A2885146EF9464378F9D1F60
+ 88AB10907D3B8D356021CC734540ABA0DF02BFAFFA06449EF7702E2A973AC9FB
+ 3F4F73AC501D0F52632686677E4CEA6070CD19E3DDD6649295678D4DF193682E
+ A1FE7B083EC8502EEE557A2FEAA89A1546115342C7D02B784C8C555D60621EF4
+ F6E81A506547550423C344812D3CE9F6935882891BD2EDBB74085F3255384D51
+ EC4BBCECC77909F7F49CA944393C43FE96088453EEB04570FFA34CC38413F29B
+ 313CC48EA23C77B4D294E6F8576A31054B2013F54F222A6153A94E64C5D85778
+ 694638E4BCE6BFBF07534E3B9F0E6C6C738BCF3D45F4D5882B519BCA7CE8E3FB
+ 75BB80CAE5BA99DDDC4D070D4CBA968B2065BBC99758985F8D74537DEB09C5DF
+ E3573F678304BD88F43C7C97D0D93D711B6B206BCCF34D8BB715049B8EF38DEF
+ B27707B02F32C4D2A102D897D05722259EF221D217A61D135F9AED2225194D68
+ 9524A467557DEB82AC6BFB5E31D172514CA4EB7A02111E92AA6FA7DB3CFD808E
+ 4C41CF94D41C9B481E05C597CE2ED6087AB0350B245A0B34592A914D163DF4E0
+ 889B814CF1421D4BBDAAEC2C9E27E1B998D291294AC2B8C2AFA7D82E5287E3BB
+ CF839A68074E4E059039CC64E2D499041E58D465018F1A7B269D48D35A6589C4
+ 1815DB551A8C22B30E6E6A88816519BBFCFDBF332F4EF79177FA17ED5F52D6DE
+ 9CCC15FDC9C5B13481B24F007D9203D109D02ECDB0A69440ADDE5A8F64C7D656
+ B282C5986A390809E17E7775E4347B39AF8BF3133360623940D032240D71C7C3
+ 70991F373CBADFB96E1E6AF1690DE868E6C07296E050C707E153A30F8E8825A4
+ 09F6F4A1AB218363E5584CA18F1FFEFC3F4DFC8C5D4199A1FB5BD5DFFE1CD567
+ 919171091A367BB2EBDA9BE25163255EA36B2C1140A0BBEB739F880DF0D3AA4A
+ EE4D6384169DC6ECAB095DCE0D53B265699D3B255AE90447389551D84A093037
+ 215FF84316A27CD70C71218031CB215FB2FB0CE23DEBCBF528EBC11C08B129B2
+ 4D285D5EEB5AC39500EB9C2274C553488F54E099D2EAAD745A1AD201FAFDFAE2
+ C4048478A1A7525494D31E92D0609979E931B1F3F6895951FCAE82FC9B69D9E9
+ E51292BDC4272C76936F2730E3F029761CC85712532618C9B6C19FED7B9E686F
+ 5A24A3B76274FC3FACB4E59213A38F1DA39F750F325F1ECE617259EDD4A14DF5
+ 3EA610F4D6BFAF2501C47CE4034C98CDF30637E39C806916EEA2114BBFFB7C1A
+ D9BEB4250DE2E57B339EAE6E648C71A7AD7D61B1C3A0B018E58977F0D2F219CA
+ 1F76E6FEF34E07F0B5E63429B266B6A68DC7FBBF647DBDDF88361F0FA8711635
+ 8020521280F846FDD9DB11C63EF23856D775747CF2D9A51D9FEEFA28534119DC
+ DD4FED748D89AD662B6F39AD8A1E094119C89284C18E05AD4B854414907ECB4E
+ 6AFC9468DB4803671A884C003D5310D52CC5CAF61AE9786B65AD5D491C496C3B
+ 5AED01A1AF15B5BCAAB0CB8BD82604A9215FA0FAB770536FBFD9F4EF604D5428
+ E2B2904F1C1DAB627EF4BD1C722C13A53E6C3714D2F0E679B5BF1D1E3C3EDF2C
+ 6C0A5FCD781B54CFFFDD564C7AF6DCE99BF40F7EFF615B8AA01BCE1CEF30A545
+ D9FCAE6C1CE43EE276FCBFAB5EE06E7D9A7C8D52339E4508DB2994B544B91C7F
+ 2525A2CDFDA676AFB00C0B3413E4FC975321C3951A1A9134C6BBB9F0432FC515
+ 9A797761ABFEF460E4CAA9587895A5E97C0D31BEDDC05DE11D0135989AAB6739
+ BEDCA26D4FA7088D0CE4919D497A8F0CDA6DAAF7BE7A99EDD028299FB49D7E47
+ 4335C4C2DA45C904E25C0EF113DB64254BF36A66BC7CA8355AC60BE6E38EC17A
+ A9FF5D2A5D32E31D7A3E91104A3B660A77B47A20EDA61D4AFDD694F99407F2A1
+ 8F1CE78CDD930AE5B25AC8CF8338024715B03C1480B64DC502EC0781AF0F20B9
+ 456BDFC690C81DEF9176560CD816DF93A542BE2F6A1F6703173D819D5708F971
+ A34B9E6AC9791B5BC6EE371019AEE85FCFD1F07EC0F29BC3973A3A04D99AF045
+ 53959CDC602FDC992A66668C1AC725F9DA702DB244FD44E26529D54A2DA39479
+ 69360C9C6BE76932B1C54CC1CA5183467431AA2766B191AE5ED9C805B21894D0
+ F211C4A33A482D8553797BCB698CC43D6E1901BDCBF86CB4E80514F0EB10F283
+ D19184D657EEB0514CDFA462310E80253B4B3351B42EB8E5EC9A413E7F236F11
+ A28737C3BABEA4D67100413C276274D7DD5BADDC7742311B5278FE5D5E616444
+ DDBE45986B2E99A414032415118AED4EC3157343CC0AEBD1794344E236B4C982
+ A656AE349CF34D03E1CF5BC5D8858C07695CA23DD10AB6505898114217FABDAF
+ F83C13C29B176CF8C553B201FF3B5F7655D8BC065A735425C91C57C66F4BBA48
+ 2B5FE5E08CDFE558121644CE5C3CD456F5D24753EA4CE0F244A4C29DB0C725B8
+ 086EA1AEE7C78C9461FAD4AE5E129B5396445D397FBD77425BBA82EED8B72C27
+ E49177A969CB7E0CF6D9A2AC5E68ACFA3106DAABDF61D3F17C015CFC24E272F0
+ D7C7867D47B61C81D7CE267CA21F8DD96DC44A99B02929EB1CACC11E1C33585A
+ F788491FE69591BFFB52B3A04EB371B876FB3019D8BB8CA40562A583FFAB1F07
+ 96D1F4A07BC2010261CB35ADEC244D2283BFCB77BE2C73120885B519D33A1228
+ CADFDBA736121C9E65B39BFFB06E4CB1DE8C767412A2FEFAE956244A3587C693
+ B3FBC3F13D274C1BEC4996F86C5A267E9F3C2FA8AF4AA7630E2E78C71A906030
+ EACE871A47FB9D92F96657C9F6F7090C845335C3B303247BB4D69AA473AEC7BB
+ A65045BC1F8BC9D346527D6C5A9734C3A1A631E6A69787B971B9DB6E73001F41
+ DC70C7E9E39481A8E4F60B84CFE8420F22FAA340CEE9BD40FA0BB3C2442CF50D
+ 0F52FF983B453407EBE85E0B4779183D15C81F0CE055CA90B28034ADAF1FC2DB
+ 2018226260CF7C0AD1ACA5C4E17B1B001DA3F4EA8D3A77F408ADB390556BDC54
+ 3D7BBF37CA75BC4FB3FE1D10C6F8D5E82F60CF2250F7E8B10755C4B9E6DEBA73
+ 28C08D139C0AF89E4C7042D1C4033B26D4C9A8D38BF62858929D9A909C70A990
+ B47DDDD33A2E1CC39C33AF528F9F2EE708D433719C38D2863486B5FD35DE277B
+ D6A3989778D616E5C29A9C3CB33D0897BEB9F54D184513A13AE5DB23D55AA4E0
+ 654E55143762C8A67E58B13ECBC8B78021E0BB94BBD9AD70AC9625B6F6F64B54
+ 5D8F6FA0EE8FCBE9590C5231282CA1C47AB83EC4E79EFD8F515216287E793F4A
+ 304056A84D2CFAF7FE55044A8B6454033E7CFE1C43BB1221A87A3348F9834586
+ AD104F22EE7A5B6A4C54B684D19AC204F713508193D2F119CC50DDF46D9B0E98
+ 9319C8063BBB4B1D29F5C5509EC88D5A653B7197F14D15FC4E7387AAFFE50E96
+ C44B9B288B46F5F285FC7A5832AA4C1CB54ADAFF566278144ADC3D1EB99C5BB9
+ 03032B07151F4F5720FDC425D8285ABCC79C15BF7A771C88F25DAAC58FCAAB37
+ 0E02BB9987A3ED3B00ABC2C022A6F29E473A4D9BAE00AAFCA8BEBBB22A9F8291
+ BF0ACFC1D83CC195612EE672807ED1AF71DC2FE49775650370C26149C2157421
+ 2E63A24227C74F1953591940B440A6F41FE2526F93716032F06A98A06B347A36
+ 0170C7DE171F8A79C22A929A9C86BFD58D7C156D473D4D0FB41CC69AEAFE7138
+ 431E118FF5AA076150445A92011D09FB051BF53F5EDF0B80AFC24F3C40165D01
+ 46DED596FD730AD4550D08F80FDC5903CD54CE629D03ADF453579377F8E550F1
+ 671E13F4E39E62002ABF4EF7698AE4A0BDAECA7DF0387455EAB10013D6B9A85C
+ A5509C8C3CA97BEB346E70933050E6B1BAD9DD41400780FBF18F12FA22B2DF2B
+ BD5520BA55AA1307050AE20FAAC134F051FD9437D0B6FBD73D32FEB181C50586
+ B5C3873FCD7CA57144823D656CC53CDDBB6F58A30FBE766BED0EFB35B6348702
+ 780C7BD38DCD78E94433044830BB22A922B7A64D4CD1D216932A5A14A2BDF9D8
+ 514975D0520D0E807AB00AE67E8B95269DAB8923ECCEA316A29832B67C4B4577
+ 1DA684C186C4EF7D659AAE1B6D4A9E254E2EBF03CAF9C467DB04E04082012375
+ D5CED21FF35DF4F08AE6A0A525110EF81FF5DA6B21B7800E00F77E601F31F6FA
+ 4663A258A3B08AD1C5CABF9C959F1273CB6FBD11C954ACF8FFF7E7A6C52182E0
+ E0F454CC626585BE4B08AAF1FBD3FD21C34762921CEA99E2FB95F2AD5CCCD133
+ AD2338E8C23D594B7DEAE476E183AB491D256825CC96AAD6966A8F8430D437F4
+ 1274D63EE79DCA380C11C7A5DF20A9D5F3CCCCEA95054A55AA8175F92F5BADA9
+ C9DD9B59DCECEA19A9F6782B949728A207D84B7B5E3D4CAF008B810206DC17E6
+ 01305738ADBF49424FCE98B71BE43AA93628C2DFE684E7E2B9ED3DD1456AF3A4
+ 85E0578BF24C9188B2D75DF6216D56F7CF40228656301A2D73776635E0CE054B
+ E2FB21383AA981975E9BDF7F3C5A47DC3922E1D53AD03750ADB52ECDFADC3EC0
+ 5BE446687ADC73594A611E7D0FC1E2E584DD33C6709D77D783FE2BD9F8C384F8
+ 6E10EB2AD4B3F088A24629D380E751B929D59DCB8775EA9DE18CED0D56E7BF63
+ 413457963D1AF8A5D63008D59735B4091DFD571B76036CDE0812592E177C89E8
+ 1A7F2F59490A521B80AAA5FC5E17FDF436665D39B4C34CC1AC35C6C800CBEC9E
+ 0DCD2605D60977DF3E3C89423DAE7650D718017E34443A75D02CA6A818A791AE
+ 6492E901ABE8CE81159EE030AB78D8A4A115FFC56AC40C11B5A43AEF644DC298
+ 02400682621A7E87FD093499820CDE8481D445CE52AAE1FA1F32413B340A2C8F
+ A0EEE45BCE6CBED5A2D2241CCB0F03FAA2417B639BEB78F964287A8744C6806E
+ D85769EF1B3B55E4AF27F194923F682CE253402B0B549413612A8EEEB409E1A7
+ A068B0F4FF8A78664704ED55A2CD728D2F18E6037C79BE27E46692161FC0D652
+ 307E157DADEF2D657135CCA15108AA44701157A19105F4A6E2BA0269C8D486D9
+ D583E6227DC92E9586A7A5F2AD75BAE7499663C4C2EBB14C091F908564D0EE8C
+ 9D388A9CA0B30A372AD1EA73C71B2D2A667BD8D99F5BE43FAB464BF3A896BB65
+ 68488718907B64C40248DA08B59B8434B7C1D9E06A5B01A852C975C520832338
+ 2BCABA9684F16147E1537FB63390A49CEB0F62DA5FF760883462D99EE5FF46DD
+ 4A68D2CCDB89E94365B399591E5BB50A3FFD6E0C8DF1C6D1E39C9A276B387CD7
+ A8BD91B9A036ADF3F8337338B40637457FB4E88D72F8FB96E2554CCC04C725E6
+ BD11CEA68CE26C875C4447EB57A86708CAEF59DAD0F9C94295952A2883554F87
+ 1B34FFD3110CD1A1F3EAE5FB9B12657748E9A67F00605F5C9DC28BC4DD4A4B17
+ 4CC9DC8FCE403BE864FC4DC63BD764B26CCF1492DDF60613D8D55CFE95B6EBBE
+ C5EA33DEAEB499DFF26A52795BDBA16387096E3C92459CA58162075A8D16E76C
+ 209022B4D59619ABFDCB0DE7692B9C4A6A5AC7EBEA0EC3216C5AFA8019AC790F
+ 0B7BD751E73400724BC36E0207AE9B7A5F2C5FC19BC9C313EB736E0729A1C05E
+ 3B6270C0F66AD5250C51D35807F20A03B12A2DF2AD58DD5622F7F8F76A352EC3
+ EA283263AA92216679C276B2E873AE9AE90F0B707A4296E0AF8DEBF4B1CB52BB
+ DB7C69B587AD1E1CB1C3131C201B48FD047F4B4F383545EC04E344A2ACF6FBFB
+ 154DC11A45857EF23D236DD2D610966FC5BB1916402561C0F9FF4B2EBA1F57D3
+ 2DE4D318F99969926C1A245CA4F613FC03E1D1FF377A0EEB59A9D5B395F6A3EA
+ BD9E15F720AA6683AAACBB5E814127F92A889231DC73FA02890EA315D3E6DDDE
+ DF3A706ED18DFE4772305E60EE62C3B4B812D7D4E8CF0276D5F2BB440C0EA2ED
+ 552EF167D62493641C2C376E643C6329D0C30749ECD0EEE25689637383B35D07
+ 631283901D227ADBC2B06C1C941B47F0617E2E861B1C0A3376F3039D47C922F0
+ 11DB36B84F39BA0EB338DDA2818D6019F6171113558375251FD63CF0B7B6FC06
+ A69CA851882428A1B38B9E53C1803A377BC2E6E0806C0A8FAA0BFBFE69353A7E
+ 9165B7E42ABC1CF87DCE55320F153A8D21811D6F673E97E148B8FFC70FFA44DA
+ 0B57F549FDDD7BD6FAABCBB7E6BC8B4FCAC7978674D849E953C14391833DB0B6
+ B7C347446DB418BA0984482A9227F949FF9F586B40446E9A34A1A9D0233B6912
+ 9DB7C604A6645428214D4BCF51A7B28A9E9E8379420DED812A1BD4B5946B6E85
+ 0F11502A845DACDBF53564E9006BB1FCFFE78262428D76217911A2B1081ADE3E
+ 109F1DCFFCB95E3348710915F2BB45A7385A63D590ACB13647A0EE8243D69E54
+ 6AA0CD9E491CA9E7A04596299047D68B6A5193E3F89E5D654EAA45D5A2208886
+ 1C3CAC25F56BDF6B21D00C494CC566A75ED25E7FE053302E24F7F030CB87FD76
+ 0AB81516E4FC55F8D9FB5C58A4A6AC1984A8C63C1AF94BC4823C93CFB1F2C100
+ D246E8E0A478E61D95295796430005F3B245D30CA6B97589F19E2F92C74EDA70
+ E5074D45B65ABBE6C2DA51F4BFD50BEAF363681D72A5F1BFD61D37EEF501B8D2
+ D0C0073705920D8B3006C7C3A15742E6F804B3371CF8D7D3C2612E559642E369
+ BF187D68FDF2D09CC4D4A60A09E2514FB155699A08A22A32CFB44299CE067B5D
+ C1598B1901A49D462B84E175530814699C5E55DF942C03A8F5CACD6C4B97CEF9
+ 637F543C5C3150503DF5D2BD419009EEA198214A644EF5DBBDC495994B024B60
+ 81455AC48B705DB1983EBFFD7407DE01E2C94BF838693594EE3536F7554CF5C1
+ 85D79983F75DA849C925AC891A1391CE45DD58EAB2602A4EAC04FC5E952110AD
+ C12E27D245DCD97D459B279BB665C72DE18B7D2FF4573278449121BD4BEC3E4C
+ D580B1F1C92DA5AE1C430D97829BCB38001120184163E68362E6FADC496E4E19
+ 9D8F81CFE852853E6FD27ED8B3CC30F9480A109DCD9D2954D6FB7DBD4364A2CC
+ 50563B92676A5835A233E42168F04EB0A899EEA9947D2CB8183E06C5A9D675A7
+ 6E48051538234F6D6415C55365E601606BBC4CBF86C50CCECD9931811B1DE164
+ 6DB0BCF58652229C2F3DDE88AC81F46D5EA3E438BA245BDCDF2242B19AB87916
+ E105046723BE6D978EAD5652045E4803B824F7DE1CDF83DAA4541C3A2BF7BEDB
+ 571C282ECDEFFB4CBB66984BCC73AC6E6E5D27A979FC02BF180528C0DAA46FED
+ DC21336197509BF188BDD2E14B59040C467CC0826EB20A30120B049332A8E1FD
+ C3C88D504F1FD997107FDF1EF040FEC8E224827D5E767209621B56A12A6F8B06
+ 79C38F38F3166890BFA3A4200C26FAB8576E9DAEA06C9E3A31C95E8428F71B53
+ 7DFA49D4AAF3E64B20AEFA10B9AB44C95B9A7616AAFB3A8240828C12FBEF528E
+ 33CAC48824B23CA30D562C81C85E1A47F379AF2E9EFD8EFF36A17B667F0BF00E
+ 83827CE6AD335FF643673BD579522ECE418105F26248879374DE609FF14DFC8E
+ D21E7AAB5F85D7BD2E602DD76CD496F3903E9AE743D0E99DB2705A5D5C581FD5
+ 73F61B2EA9ECAF0365A01D064ED376636F9DBECF1BDDE584F17FEF893D0676C1
+ 771A3FF1A6FBA6C6BACFFA74CBD8D1122784CECD684C2195B9A3CB80402A6DD7
+ 4ECEEA2156E802A500C74270624EC79F8175F5B6145E2453C4F1EE53F8CA97B6
+ CD955CA53FC6A2F599FD76D8006B0AEAD000C22078AE41D1425250B425F6D497
+ 518A8D478AB06763B97D0278750B06D54B0532C5554F0EECB471A7E3CC95150D
+ 3F52549A44AC84080F536DF3D6014FC47AB0CF2AF6DEAC7552B6BCA445A21234
+ A0A911BDFA9A13116BF177D717396CCFEF33DFF8D76B4A5B71153E2C0EC3AF77
+ 998C8A0FC1E5985EDC955E24D71B11936FC02CC56DE58BB576F827ED84433EE5
+ A875104803EFB76F073A3C035C452267B40153EF1517E6C93D874B7BA0DE23D3
+ F4D3ED09FE3252A53D46B4717DE9AD0C4CE7F319CDAB8A2B508323C84155ED69
+ D5D5F53DAA25C95CD2C67B06FE5EE1596C55DB26795901F0854FFE30C786E77E
+ 7F56F8400AB442758FF391AD17569AC413AE12489CCBE11AE74E5030C3504CEB
+ F94A67E6001E32EA55E3ED045ABCD260202E1D26E3D8F2BFC7F43D16FB829C90
+ BB5E48603CBA1B32748000B5B9712ED07FE31E9A9E10DDF42BE87FC672E53DFE
+ 18279203AB93FB10DF5091C24B4CDD927B8318DE7C4D1E4D8E7EEDE7CB30A124
+ C4947E28A48B6C6AD1FF12B991E17C3B87919AC33B01B4642D6593599924F0D1
+ 1F2C439C68960CD973AA441D84D4FF37AA0DA188BC61BB6F3C4428FD7015F07A
+ CB58A6DE0B7B0D99ED49B3EC357992ADAECE9DA3F11D023F8020DA3B062C6B35
+ 52EF2513902F3B082337
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMSL10
+ %!PS-AdobeFont-1.1: CMSL10 1.0
+ %%CreationDate: 1991 Aug 20 16:40:20
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMSL10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle -9.46 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMSL10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 45 /hyphen put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 76 /L put
+ dup 77 /M put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 85 /U put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ readonly def
+ /FontBBox{-62 -250 1123 750}readonly def
+ /UniqueID 5000798 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA0529731C99A784CCBE85B4993B2EEBDE
+ 3B12D472B7CF54651EF21185116A69AB1096ED4BAD2F646635E019B6417CC77B
+ 532F85D811C70D1429A19A5307EF63EB5C5E02C89FC6C20F6D9D89E7D91FE470
+ B72BEFDA23F5DF76BE05AF4CE93137A219ED8A04A9D7D6FDF37E6B7FCDE0D90B
+ 986423E5960A5D9FBB4C956556E8DF90CBFAEC476FA36FD9A5C8175C9AF513FE
+ D919C2DDD26BDC0D99398B9F4D03D5993DFC0930297866E1CD0A319B6B1FD958
+ 9429B9D40924DC059325D9D4CC0344F3F997A99E6CC0676735EBCD685AAC9142
+ 08DAFEC78BB41AFC2F1C219910BDF41D6279284EF600B69776CA15BC8A34347C
+ 30783C52AFA60FBE3E353E2AE354CF87B558776A22C776C7A0B5AB5CE1F941EF
+ C2D9CAC37294BF407A671F10E4743BF842143F4F7DFEE643BA3BBD8BB9E3F24A
+ BCCF7F0ADF8BA500620C81033EAE8C4EF2C1DEF13AC575F1B3BBB66F093D3B78
+ 5412B82B67FFA087AF57182B2230F9F2137180CA58A7D9B2C822FF04BE6CD01D
+ 43B2CA7058C7B953F6D9B5D6E91ECBAA5CDE1159B0E59C83DBAD96D6C8C8BAB1
+ 374EF652D10C0F3EE7104472C98DD3572AAF2D45A70BF7061447E21EE3C3BF23
+ DF39C2D1B35B42CD5297BEBE6BC94F7C9DC6E61EC67E4F677256FED9064BD3E4
+ B51A71B1D27CA4E5AA9E1D8080E6DAB5310711EEF87C40859FA935B19524AE83
+ 63B163FA8397BDFF443227FEDF7DB27DC35D89FB1C5E435DA0619A5C88AFC73B
+ 89A2DF5E767C5B536BC7167A840A0C32BD57A14DE69A7D0D819AC36FF32F908A
+ 5070F32983BB007437E3500799DF5E0AD3710A4C0000F0098D5BE99F2EB9C1C2
+ C444FD9552D0DCA098A94B3BF176F511CEE13DB7EFFAED7C47B5ADCF8D4700F5
+ 7A5FD1B49560969BF5C44F3749370663A04776F749DDD7B50674D93254426C4B
+ EFE264BEE7810EC93784B7C01A7F29EFD92547E13A2C7851A2E709FBD5B87850
+ 4A44F08F56A542DBE072D2FBC58D9E6468E1AB858DC35240E30D31C7AC13D6C5
+ 7D2BB634BEE96FA0E10F842B11A789F72A333DD6DDCB1BC23227EBC406E50B40
+ 30AF0C48E6359AB0C46898CDAF1118E46BFF8B00F54EACBC2AC262AB898C42B9
+ 2E080C10DE923C1F7BD11CA700DA95F7E94C4C77EB24EFB7D5DD39CF43896343
+ AD32237117AD4B4C24EF2B9AAB4228720C9F9EDA61ECC327D71641E9657DB045
+ 3E35C6ED9AFD4B88FBBC287F2B08E23D1877D30738C7B58A951B6F16B913F424
+ 724C1F4F852E01584309DE7B8291503D21B243104B9FCF10F15B7B1B41214884
+ 04B3CEB35C95B2A5CA8A57C38E4E891F83058984BD61B8B3A73279882545FF0F
+ 77B821046A1E822D4C3FC310C6C3B8E74CF438DCDEA073C2DD445210021F9917
+ 3F42912533447A9D01840AED97E0537BD4ABDB6995B6FB24095BACA330397327
+ A039BF1DD9E5CE8707BAF0A65FCAD4EADF49AF6833838DD498B708A85AA36DD6
+ 94765B836B263A4E0D38FA0CAEAF6F8EAE179FAFCE5E9F450147DFFD1A1EA355
+ A97D0C789C9F142E41AE8E27608D7716C28801275D7DB12AC4A69F5ADBF3A7AB
+ 45F6E2E31B91D0910BB49120005D585D30C08076D0CC705B0F78402585EB1B25
+ 6414ECB80681D2B5C8299F32DC4AFC73D83FF2563CFA95AE9889D7FD37B29A93
+ 61C8C77B63AB5346EAC55E4454B0410685D2C5873D9657A86342CE49D22053B3
+ 707397FDB0FA88886C3F1C78A81D7A12D4D110B42FC2CBC6DEF4FA26B263660A
+ 0402140273FDDA05A2918C0626FB9478C43B1FE06E058404F3D110D9665A8DFD
+ AB8D73F374DBBF467333A3F78198EC67EBFB2AE9960B87FF0192C1967DF26D7C
+ 1B0D787B699EC120142CF9494E89A1BBA4DAF44C8FEF93B171B3B2EC3A1729FC
+ 0973D8E51B96A729A30B5CFC2826285A8FE8E1843FF75E8293F213B48A7D3C11
+ 3CFE721E83E8DF6613534177BAB7BD6B77E4D3315F1B10EABF7C8242284AC6C4
+ 1473FDDB56008D9A525F36D1655659723E606F92D55B6E31F2E45549AE250CC3
+ 6DBE0D796E0D3B883B3B045ADA99C5180FAA5E8F73CF3BDC775BEB959375359F
+ 020002825EB0357DC5D13EA1AA389746C0D1DB66E45BFDAE5F4E2846F896F9AD
+ 437997A1397E433789D8D95DE29BE17374A3A26C51471CEE5336646A18208398
+ C04C29852F2A89845507BFE2D5FE1AC6A9E80C08F0629D0CED024376BF04A3BC
+ 76EB1425CEDCF52738FA08EC5A7F82B698BBFA2D934C0A823FAFF696DCEE9F37
+ 084CEAFD11EE46F4376C43AD5EF81C8EACCFE52D2A9750C6CBA92A99F1155941
+ A1BD351A49CA401D3BFCF568FEF7390312A99760E2BF4EADDD55ED2D8A26777D
+ FFF9ED8A129EDC03E54C99E3B0F344C418DA34AAA6FD3B40C1BFAC3F2BA67A7B
+ 24DDDD49DF78479FF71A70602278739D9996861DB0F242C1CD835900AFF84EDF
+ C44418233486D1BF515BE5186AE41A476E570499251FA294D6A97393DE72A675
+ 0C5BFB8D19AFBB759FFAA44EDC8921F0FD24CF281CF3D442367305F18227C83F
+ 2A340326F0FF8E1C1908924D8CC0C457A854A3D111770BD14F851738052701E9
+ B115F048D4D6C5AF8FB09ADD2577A0964D64DC41A25EA131B3CDBC9DBC719885
+ 10C360A7467771D3D356B0F51AF7C5EA2DA9D8D706960C75A973633CEF79ED70
+ C9A5C50BF017ADFE23E998AF4EC96BE4343A6F3A709821A9ED891F1F0B1DB1C3
+ 4028DA4AF05211223FF3389E9BBA09DEC7AFAD7DC9BFD1D064A19A4B5588DADB
+ 179DEB3D91472973DF627A69AF67C3034434EDD4E38C422250E36371C626ECA9
+ 8400485421475E085B7D9FC958D477103CCB66500330A25A261B36605DD7B1FE
+ C966C4599DFBA8A6D201049DD3D012D8681CA7F8556C8033915895974188BA34
+ CFE298AD0619EB817DFF993608B451994F46D0526F5DA559C13CFB4F4AEF66D0
+ 8099F1F48CD07CBE093BDA769B49F7982735FCAC7A7A37D536578BF8AFF3189A
+ 57BA89E4A0A7BE2C24FAB94A13665E18F32AD734B8052C334D4040D43950DBDD
+ 923885FADF4BC45B41D71A14314A15D82DA9EB6BBD02CDC835CA35E28BA57D8E
+ AD207A7E3DE614D0E5CEED9BD3D4ADBD1D1C6F66AFD482FC4C75A727CCE0B31C
+ 5CE1146646154808FDA69E9D495B3A7299CDFA17469BD5306FDA203688C78397
+ 9F0DE61E513548839E80D1686629242984A7189877E0898E6F5EBDE8C299F800
+ B125893F07348F9C1EF239FB3C7FBCB0829CB8A04327FC6C98FA7A3CE7B46F56
+ D2E86DC06A816C0A4042D19E7129D5A55D78387DEA268F2EBCDE8EDFF9D25C6B
+ 25BD153768B4D5F2AE4BF6924AAAFE68063738B57BA2B72C5AFE03039B22A2E3
+ 45386A0CBC2262745D664283694E656DD3AC909FCE63E7C3CB35ECD02C13BE28
+ C324CE18B6CC8CE8CCCF45B7AA67116D427D90EC92323B9D04D8DAB612B5CC0B
+ 0251835781D102597D12355E48BC5FE0844FA3410E85D127F2012D4960305B5F
+ 4FF28EE419A5D0AEA98785B822BCF795A60A0532E061CCF1F196F4AE6C269C63
+ 22C8C52FA43E807BE07E29F72DF7AB7ACA00D03DE8B75C1494CD32B544562FE8
+ 326DF1CE326ECAC7E2B36920F50A4CF47048BA7FD11D258438AB32EB02EE567F
+ BF4A5AFCD9AD73216448C9A005859184A8EBBF9B24F0BCEE0BE4E21A9FF91280
+ A964094CF1880914AFD268BD7B21B03A7DB856B62CA473933C86B982CA43164C
+ B2F269EA4A46DEE5783819DA76E26EE6346ACFA6F312A4D03973E6D02BC516AD
+ 0521E282DFF84B4A375FE289D5D90BD52B893A994F8A9ED283445322536709B0
+ C78F56D8D59E28EBCF8ABCB7E2F9B155B750D2D8AB12FD9D797EA8B582D08557
+ 5B10E709CDCC06ECEB0483085F9B8AF5871724191E0C0D8C807A59286F87972B
+ 7444025AA8C8FEA5AE481894903D2F0E54BC9B05D56D1364BF62FB697A13F88A
+ 64F73A95357D2412F1D396B14F1BA230F6EE7338D888911AD117664057BE5CF6
+ CE929EA8A91305E8F2D7C7DB57FCDEF38B5F3B10C484366384E867669ABC0962
+ 8CE0078250FB70E22CB4CEFACFAD87159E92E7D6FEF2DFA713BDA74F347BC16A
+ B4D5B2781119FC06E1D3F81667FC93552600C71B8464D5FD8FAA42EB9F91EEDD
+ 4472449F497386E0409CE4419C39BDD3A3BCC5732CB44C7258F8465C138C8D46
+ 036977AF29F9C4935BB1C8CB3133A8C72708EB546444031426261CDDD2534CC8
+ DA5D03CA4BC01F37701B21765AC02C1BCD725C5B220815A4C1E017BC99452677
+ C7A62F8DB0B3A0E39BC5FD091C3C385251473238F9F9E01CA877E2A48F391406
+ 359A8CAD535627CADAD2715A0369C2E3A980D4772E0FB9B2C9E15BAC26D47D98
+ 3A884679BC6A946156B83105D9A80D0844CCA38BDF86EFF26C2DC9839919E3A3
+ D45D9B60941E7C0F0DC340F8C852ED66C3AD364E6A34EC266F80F2612043DDB5
+ 73E53C2B686DE116207BDA0A2A2554BBA92F1CF195826F4F5001146BE39C706B
+ 769F201271436CCED6C214FB7244EEF4CAFB90A3B8D074C17AD30E4F08FC8592
+ 99B9B13165D0914A57E9A56F544213113B6918D2741BEC268ACE53C33BB74CBB
+ 9122B9B2F17CD80AEFB203DEF25B1BDB37E623421B963D2C5716BDDEEEE1F71D
+ 073DA932B4CA93427E1119BDC0B3E58AEF51E1EEA74F3F56FABBADE0567DF71A
+ 56CC15C9421A2AF10C428ACBF09AB8B33806CD1C82F04B549CAC3E81FF05058B
+ 2B0A8F0B5309B1BBC24DD89FAE5333A85DE550DAFAD91C5B6CA23E218258141D
+ 17B2D5AB84B5BA75243BC89836131F7F119FF4B4ADB752616FCE6FB8A7DC000C
+ 2714EF0C6D214C05DD409864EA02D7CAF5A95ED2C4DF13720962BE7F2422A477
+ 152AD86D91CF95D610BAF6C9506724563C90037FE9BED417F78F65F9171D1990
+ 00E98FB9C1644B4C1C9E772D3DFDD0FA76513A247BC759EB8A2BFB9CE1AAA603
+ 3454AA70E3F4A92FC2F5EB8ABF67893B7BE50C18CF35428A2D9E1FD9E26D0496
+ CBFF98C7B94418F1DAFF16B853B577ADEA2A834E73CA9762212ED007EDC11954
+ A0AE5C0358760855F3415C78709961E5888B2DCD0341186EF437392F51FA2512
+ 494DC5EE33D9A689F65417215637BA2BF80BEA0D1FAE18F06D895D87B75BCDC1
+ 70C02C3B58C2FB00F3400449462FB0975C90F85CB268F4FED16AA24ACB8CF48B
+ 538975EBE5AAA939A1136A4B858CCA260D842B61F311C29CCBACA3AE933915BA
+ E89F733BE339AF068F2A3D2C403A8405A1840BE5F6DFF2C29291B9DB565BC1AA
+ 8456722EE90B99E3B34C6856855A8981C934D8F113C7CA62AD6599A7E48F8618
+ 0CD4A9FE09657A8A6F11D6C6E8DB793B1C73FF3D34777C1D5FAB0AAC8D107E17
+ ADE871BEBB5947A8FCC6C1926493B96DB35C51CB63B94CFCE9A38C595F491C3A
+ 94C037C5E6248E7085728B6EAB1F30C50D7D9126318875DDD2FF851849A36B0E
+ 6526AA513C1CA6D6A0D4B247071A897AFA4014E42A49335888CA7F3C6878E5DA
+ 42736ACA103A599B77385600CCF93799A644B6A6273B78471F91809C4744E841
+ 24398AC611F0CE39DAE066B63D03191A30D383AD6ADE809406C193468F3500B1
+ D44EAF786830F8B9EEB152EEE10EB8336432CD5C84DFAAF2CAAA507B36840EBA
+ DBDD1593228D9F1254129894775CB5EB5537148AAE90353EF86C7F539E7744FC
+ 0E798BB214891B3B5ECC6A0A938B608B55546B54F38FB24CA783F3DDF31B03F2
+ DE580EE441BEE0C16E3CE11D8EE220A85E8F76F55DF69A24FB74B74E03DA92C9
+ 9C3AE0A6FC53994984EEBB130C8A1BE5E59E1F68D958B654E52A15D2ED4E9F34
+ 1D16A581812BAD8107D0CB10648567C4B131CB04A709BDDC5F7DC5DF26D798F9
+ AB85074B790F387FF86AD9DC6EBDF12A32093E986C0DA20D7D4F023D2D4DCC2A
+ E000A2E1B44A717C90BAE15C3AC6FAAEF5C268E0E014814A3D583A29A6EF8953
+ 27ED88EFDD62780845A4837E7BCFF78ACAAE8A829A8AB2D7C35B1CD8224F0023
+ B592FE19CDFFF087CD751A29163D96E026E127926977C82CD8768AE117E54DCB
+ F87E1F69268772B370CFE6D3352A001F0D140E973EEBB62A23FB859B57E17385
+ 18C734210FE67A98253074A3D12765B13ADE2003D64E60400DDA90BB3F51F563
+ 8883465DD231A05011684F583E00417706F12E92B61891242B1DBF8BA29A562B
+ 378E457464571A0F0B7BF8973E2FB3BEF70F65CE05425C877DDD44F7E519CA43
+ 019F429998F7A25F4E2DA3E904935B11903A71FCC4997491B0225A9CDD8712F6
+ B1B04F05119C7182203B34FE91EF182EC23B1D14191043C51EBB52E32792EC37
+ 7A60CD51982E7D2B16721E7B825E6D550FDADBBA57937751F59C1827F876D2FB
+ 32B9BECA20E6888B25AE2AF18104C125E7DB353DB294364C01BB496DD6E9A4EF
+ 03139CC638376F9FBEAA21709B4DF306565B0C8040B6AEB440FA18CDADFF0292
+ BB2865885D4F4811D42796BD1A49D49B99476C884DFBBCE8BEBE8EC6447A8C60
+ 514CC45AE39CA38969DFA801A0145F34412D85D4EDC90E42B990CEAB85C52BE8
+ 4C4A243A7B9E2DA9A18D65198916AF06C1B895CF664EE835D2A5BC6B4D35EF51
+ 9A8A7B8AD95BF85014D5780F392F70FA657A09D9BCEB96B07131B4D0D5E2CDDE
+ 98FA88684FF60F65FA5479F39BF16EE0918DBAC613FC0E4168B2D301EC0AE5E5
+ 87F7BCB583B0BF8C19276A75345FB951423AB894A5AF2B6E17AC640D93D147F6
+ 383B456BE919FA542191DAFD9B9CF743AE69D5CDDF3C40AA285C610A415E006D
+ 2E08B7EA944D1D97656B86B856552011DE047AB31D05B33D850075A6F1824097
+ 29F4B70A0CF0E741582EF0694B38E90A4A6F63B370462AE10F1738A56BB6DC4C
+ 840B4B19156F7688B84BD7C41A14D88E43A1C5447EA70A835FAA79850426627A
+ 9DB462FDA4EE5516D49D29B4BE17360DE910A8051B98244EDF24DEF094763754
+ B47D1FB4E6F8FE385F122219257CD9C71E5E0B9E27573FBABDA1643CF83BBCF8
+ BA44C31808378181F9452D05B3F8232F3B95ED762115F1576C260E8E292D9B55
+ E16BFD7867131FF697190CE4BD21C74A08C9B1F9D627280572C8C01F00B954A9
+ C984E4484BA10D59CF54F0A41167963169DFE865E63B6811A4F2FF310CBEECB8
+ E55A1DDE780035D277DCE5073B1E2982AE2A0D007A8ECB9FEB2ABDDA9D82ACDD
+ 01CE81E46FDF549457D76836C88F5CC97138479C489C0C159FE30EF2B666E568
+ 65634331CB4D71555269109A01C4CA28013CF4602F8E6440568897B33C151687
+ C3D20B2A706BA5AF22CF7ABC35778344CDCE2769BC515F60CD2C1D3D5782448E
+ E739AC0F74602404E0EDEA5CC6672AFEDEAA05644A24250B11BAEBB4D4B854DE
+ 4782925F4EE8C0F9C28FD47EEBE575D683EFC2B8C30CFD5B4CCA8232F56B7748
+ F7A3C4A18F59BC0AD9C86F541B2C49482148CEAAA5F3446D7758325179573266
+ 78616BBDC1C1EEEA5468D2B3D5AF012A0D8DFC6A5DC253D709D449A1829E64BF
+ CAFC1806E7CBC8F1AAA13B14703FA5269AAF47194A6F8952882C2B3AADE88AF0
+ 301E41D4EF1C683FDC1AD518C236045F167303B9C5E0D75E31CFCFCD6BF26303
+ 64F7EC4147CEC36DD502E94238B1EF3B19BBBE6031492E2ADA5B031E4FEB194C
+ BAA49C0D8EFED06588C134BF7FFBC64F93DD5F580D44135520B38D28E12E325C
+ 43353A20B8FF40A192CD98AD537624A720E032C23E578EE7D082FE036D29F436
+ B8BFEED994EA42F54DECB19580968A3F2DF6C379BAFFB260FA3B6143C1127980
+ 84A5EA1986BD99AAD2B4F3BA7B3A634DD2BB8AA645DA53AEF073877CABF46D6D
+ 84C34D8B4BAE179936D0A10893F77BD53E77423891709442D1D6274D24289BC3
+ 9389EDBBC178406DCEBD1869001020D87751EF54A6AC2A6EE4D329BA279F43F9
+ ECA24C45C1886ADF51A1688E8B78D4629E7499885D861A3A9E804D84137C75E4
+ F93C47E257F5B36FFE67110078C44CDC7049AFB4BC2BEBD141E741366BB25A5C
+ 70CF81F93A8DCD3E48A96212619000F4087E95E8652FD567D0DC711555BBC613
+ 242A195E0D46B386CC74F59DACBFB072C90FEF50B3C1392EA5D42C0DF9C64F16
+ B57D895D16135057CEB276F5C4A557EA7F6196EA31D9648BDE3C8486A904660D
+ F6B5B218E9559FB5F48A48971925B01947B9B7B6AC492D749EAD5D1AF4C83883
+ 61DC525CA6A8ABF5B7935C0C849FDC43E4F0D327655C50B37B6FEF1EF982E88A
+ BDDF885E486BCC14F0BB6258661E113AFDB14E7769AB138BA0DB00D0BC99A3B2
+ 74E06707E4BE0A5DFFB572715168822FE03CF408B3D44B2BD8C10703DC310D39
+ A547712C7EF6537F679A83F242A44368475E6263F192BC283DE040D9DDC1034A
+ 72F8473089864442E8BB0D997F9C3D47F78C5C6C879941830040AA70C81140D8
+ 0A0595621F00647FA1BECDC08996A09401EA449B55CF5BBB95DE077E894980A2
+ E8CBA9889546F6089DF18CE423684B9D1E764FDED6626C7319D746A98AC0F9B0
+ 7A1F55C3A94EA2D75B39D01807428C57A8517224D767A34B2BA919B615B84B01
+ 2DDABBB208BB49B142A1741AC35CB35773801F323707D0EEF1994DB70E6F96C8
+ CE36658EC7C092D692E83CC0C3E37ABF7301BD181399032CE5A4F47D6406C7FE
+ 11DF0FA2A81F333F43A598E674FFAB2CBD7A898A06B3FAAC2419DCF1580DC4E8
+ 3D3E678635BE83F89D9A84A3DA706D021CD701BACE9F0EC0C0FEC296881B2D33
+ 624700431470E80FC34349209F561B15EFC729AAE56109331B73AB4E21F4A7A4
+ 823F43DB72E0D44422F7A194453FCE5BF474A6C8620E05B24C1D065C46D3E587
+ 03CAF0538FAB500A6981D4771753C8EDD8922DCDA7E19FD6B440043B8DAE0A2D
+ 165DABD05DAB6F77DD9990402EBA7252AD0147528D3D9F0A82AA5CE581670F72
+ 5847B541F2E687A1CCE10BD861D8CA74DCD32EDDAFB9990FCF2BC7C8C0B40FBB
+ 12592A5CB8A4A952D649212EC20374D07DD439429EAC41E54A444BA2FDE43DA7
+ 7AA980FFCC9C2B771099384A2E6D0E40C108E3A20ED5C23E4CA84FDE602980C6
+ 439DA8116E1E039423907DF7B2E631F2B8573ED912CDD1A36049B55350397D77
+ 06C060BB528A62C0E8294A7A28484A6F8D0CC24635E8A79CABE1C1653B557BCE
+ EBB2B1391332641902CC7FBD142EEB3A5320EEFB0E4987B82E10A54D3A600AE2
+ CF0A7A99E1CB73B29C7D7076D7EEC02544AF0F212DE3B4EF36AEE61FE03D1D5F
+ C0E9AE1A6DDC369E553FA228A659CE3FB9E37B15AB6AE9EC505DAAF76EC9BA32
+ AFD69CEAC3872A83EF79F5DF78D90068A5F382ACA7BE2CDB3BCBED5356904B5D
+ C0AA38F9BBD9AA2762628DC95A6407B06F1EF19938221D94C50FB859C6673608
+ 0A99EF19A1F8B75C7561CC3C5560B7E41064A0534D10B29B7D5EA32C2C769E8C
+ 6C25040A001C8B920E03EF9D4AADAB475EBB50131C37B843457D63B6AC7A9DB0
+ 2A3F62CAFB27470129D59F364FC0C092BD2F1091ED37D84283FA0315FFAA3B82
+ 985D8A8C976B6E56EF590B50B28969A2754908649D166DAD68ECF572CA73B49E
+ A0E953E123B602B739DB41F092B5640D2D3C59221CD71251E720B48911997C28
+ 37871376080B1F2504D210AC1C38A97D72154EE3B85DD5DD4A1AE31B482754B1
+ 777D7A44707E96DBB6D17351BEC10B0C53D45452BA5E5B9D72051569DBDADE3B
+ 5DFD8F19BA541DE5360A12C5300C81CF25EDC17C8322DC70A148BB8374FD4DFA
+ 389B51DBB3A1C240CA3ABC84DF58D91CA8477D166F981DEC52E42E6E29792C15
+ 02A585FA16A8124DF6332585DA017D04FEE141875D9646A3C064D0BC4FDB452A
+ ED1A456652083A3C2C941684E537F69B2F16ED6BD240D9F88958B20257DBD21A
+ 450FC9D496C6B8F724964CB305189597AD06A97BD337729846C93ED2D7EF3722
+ B99F1FB3CE8528D37ABDC85E2C223BE3C977222CAEDA707792F847BA76858771
+ 62438229CFC3C21FD7F87E739191EE6D153E38C835FC206F2860E1C47F38C575
+ A062973512498E537EC172886829CD4F5B25025B91366001B783BBC3E9089F8B
+ 62B2214F454066004DB8E538A41E04C9E075CC9BF503E1EE23617E1AC3109AEB
+ 0C6CFEDB486BF0706E57F3B5F0DB0556B3E46AC6416C8CFB0F588555069846F5
+ E5B926808C6C085538E30516519ABB486A28B9D415859A5A22AD3A0B6183674A
+ FEC9A78EED8DCC16B5BC33274073FE4320AE05505F393BEA17B2AED77272799B
+ 80CACAC3F68E76EA677BA5620BD7BEA21E2CEA6C0C2E3C1204FDFCF25E1E6ADA
+ 14899B3996D26B7268D1010DEBF56414342EBB9F80418F9CCF098D9DE6E261BF
+ 2BDEFD915F5FD66A2D4D04A1340FD44C351CAC017FB3F8D4E6EBCFFE3493BEF9
+ EC55E4ED8E08D2470337421AC32C6D9AA8F2E133F7EF489088B41268C621177E
+ EB99FD28CB4606BEFD02D89CB167E059BD44CBD00A2746660562CE95F528789F
+ 4FF39659D4BF94C5E73E31EFBC8596F3A876FE3F84A9E4A336165E63C774C18B
+ 7CA76AAA739BEA61065D58A4DDAD0E6A2F3C0880B8A0F2B91926578BC1A88E8C
+ 6145A4AEBAB84BA5D762201858BA25726A85F31D2D803589B5A9F5C29F4142AF
+ 6A0849D12F9E28504FF3BBDD06543949D17F428198D6F9F7FF87CBE830AF3902
+ A0733A2D55CA47385266060D3F1A84AD3C1E4366DC5D1C4C4E2140A99BC5F82C
+ 022E0ABCB8280A099745A4B497A6D59A148E131B46AD1D862F2CD36DBD498EAD
+ ACF2E3B02B1AF21459D7B8F2D12FA34D06AD2140F90D7C3D3A522A3E7E2F1C86
+ 9AB9765D41F203E8F618F2D7B8771AFFE13EAFC683AB972B1C212C80AC62C56D
+ 06DAB35C260D8DEA1FD888A8FB90EF83B3CBBCE35A4CB073772F57808E3C6FFC
+ 2E693932E0C8AB1BBDDC023F710E2F3C63D8313AEC82AF6D3F243AF1B11D73A0
+ 58EAFAB69D630D30B1D212AB1AB26985ADF7AF12703088BDBAA28FD8A54FC0F3
+ A1B43569A0916D372ABE6C06D22634E993ED03B5E8BFE26439FD3B9FC908AB20
+ D6EE4D9499F02C6DB8483ECE811727FA55C21D2AC30371BEB75B7D7E41710E0F
+ AE3968D08AB3C1C2F04F76BC77456D34171454C7A0143036DE5220CFF9C6150D
+ AF0F4A0ECA1067BA2852DE325A9AF27617EB5FD132D57168980EB8D2C4555404
+ 8F3D5CA29DEA09BF8C58DAA945E5DEBD9EC7F41B94986E457B18FABB79606E2A
+ 1B79739013B76281F33D06028599DA568295DE332C2FB44FDD984D73C9A1D0E6
+ 76A33A03BD2370A0FE3D855A756B27B8A65D2BAE11135420096E1CBA096AAAC4
+ EACCA0FB32D08D7A9048787258663AC6C8E32EB6C541835685976A59971ABBCD
+ D448A3E7D5CFF6FC9818045AFD86E3A6CCED1AC53AA096D8CF8E041185BA1782
+ 307B3F1F6FF7536832EDB706AD3B32BFBF0D020CC0940A06CB440E292584A407
+ EEF65E7B6421CA38D9526D27E150887BEE86021650669799441CE8D0C0B79131
+ 71ECB16C3F4799E8B038F20E4F570603534C16DEE89B404CDBBE9C91D31E80F9
+ AB528D3485AAD0BF6AC2880DAD9702E1C0BAF61FDF7F3E366F945D2465E8CE91
+ 730926CBC9E13BC3B61BC76924C18906EFE47FD26FAD78288AD225217A60FD18
+ 55D4D7A621BB9536D84FFDA12C75C2E5A3B235CEB3E0CAA6DC1F33BB04526169
+ 9C7C02E6CAEA235ABE59DEB9C7ABDE5DBDA00390D7603007EF15B842AC6E0D5F
+ DE4B53B50DE2045C2B2657478DFA1DF714DDACE02DB65FC769653CBE1287443B
+ 1EF1C91FFE4A7C4566C1
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMR10
+ %!PS-AdobeFont-1.1: CMR10 1.00B
+ %%CreationDate: 1992 Feb 19 19:54:52
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.00B) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMR10) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMR10 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 11 /ff put
+ dup 12 /fi put
+ dup 13 /fl put
+ dup 14 /ffi put
+ dup 15 /ffl put
+ dup 19 /acute put
+ dup 34 /quotedblright put
+ dup 35 /numbersign put
+ dup 37 /percent put
+ dup 38 /ampersand put
+ dup 39 /quoteright put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 42 /asterisk put
+ dup 43 /plus put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 47 /slash put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 61 /equal put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 74 /J put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 87 /W put
+ dup 89 /Y put
+ dup 90 /Z put
+ dup 91 /bracketleft put
+ dup 92 /quotedblleft put
+ dup 93 /bracketright put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ dup 123 /endash put
+ readonly def
+ /FontBBox{-251 -250 1009 969}readonly def
+ /UniqueID 5000793 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5CF7158F1163BC1F3352E22A1452E73FECA8A4
+ 87100FB1FFC4C8AF409B2067537220E605DA0852CA49839E1386AF9D7A1A455F
+ D1F017CE45884D76EF2CB9BC5821FD25365DDEA6E45F332B5F68A44AD8A530F0
+ 92A36FAC8D27F9087AFEEA2096F839A2BC4B937F24E080EF7C0F9374A18D565C
+ 295A05210DB96A23175AC59A9BD0147A310EF49C551A417E0A22703F94FF7B75
+ 409A5D417DA6730A69E310FA6A4229FC7E4F620B0FC4C63C50E99E179EB51E4C
+ 4BC45217722F1E8E40F1E1428E792EAFE05C5A50D38C52114DFCD24D54027CBF
+ 2512DD116F0463DE4052A7AD53B641A27E81E481947884CE35661B49153FA19E
+ 0A2A860C7B61558671303DE6AE06A80E4E450E17067676E6BBB42A9A24ACBC3E
+ B0CA7B7A3BFEA84FED39CCFB6D545BB2BCC49E5E16976407AB9D94556CD4F008
+ 24EF579B6800B6DC3AAF840B3FC6822872368E3B4274DD06CA36AF8F6346C11B
+ 43C772CC242F3B212C4BD7018D71A1A74C9A94ED0093A5FB6557F4E0751047AF
+ D72098ECA301B8AE68110F983796E581F106144951DF5B750432A230FDA3B575
+ 5A38B5E7972AABC12306A01A99FCF8189D71B8DBF49550BAEA9CF1B97CBFC7CC
+ 96498ECC938B1A1710B670657DE923A659DB8757147B140A48067328E7E3F9C3
+ 7D1888B284904301450CE0BC15EEEA00E48CCD6388F3FC3BEFD8D9C400015B65
+ 0F2F536D035626B1FF0A69D732C7A1836D635C30C06BED4327737029E5BA5830
+ B9E88A4024C3326AD2F34F47B54739B48825AD6699F7D117EA4C4AEC4440BF6D
+ AA0099DEFD326235965C63647921828BF269ECC87A2B1C8CAD6C78B6E561B007
+ 97BE2BC7CA32B4534075F6491BE959D1F635463E71679E527F4F456F774B2AF8
+ FEF3D8C63B2F8B99FE0F73BA44B3CF15A613471EA3C7A1CD783D3EB41F4ACEE5
+ 20759B6A4C4466E2D80EF7C7866BAD06E5DF0434D2C607FC82C9EBD4D8902EE4
+ 0A7617C3AEACCB7CCE00319D0677AA6DB7E0250B51908F966977BD8C8D07FDBD
+ F4D058444E7D7D91788DEA997CBE0545902E67194B7BA3CD0BF454FCA60B9A20
+ 3E6BB526D2D21FBD6D78E21A936F2E123C0F6EF41AA2266CF51B513EBF49D4D9
+ 2C0C93820A37010A4C8990B3D2551EEBA36E8B8DC122B1432A6BA9A8A674CA2D
+ 5F3DE1AEC33589A13F6DBEAFAF69B753BC0DA94017AD3D1CE981FF38A306FE6B
+ A6A35630A7D636C1FCDB936F6BF9366ECA151A7994261C5753A081645F671114
+ B5E2F6BC08A8D70AEE71C81471EEAD30DCACA08D817FD44D968C90C13CD61C96
+ 450AFFCD62A4DC0AA440A045DFCAAE74590B3DD20E53BB454DB1D1CE0BC5EFDB
+ ACD8357B38D57AD256B2271C04919BC6A7394F2AA1D1820898E726AF96F1A4AA
+ EB28A369B460831836F084B0D4AFD3627F1F2E08EB4C6265BED1C8B6E64651B2
+ 51F5E30028E43296A0548F6683C9241AA96C01F7B4AB203DB761FDC536FDBCEC
+ B22FF5B063D808ECADAF3969E4697995ABABB9715C492B201BF5146D61066780
+ E278AB7CFA6BDC04E55F2C0C1F2D4C0276E0FFCD0390BB31920407207AC57329
+ 1E6E5688C00BEB6C5031C3E0E116A9C711264EBAFE4EFBB816CE9EA5EA827C5A
+ D3F494E59E191D6487269BA5FDB468183A6E36EC7D65E4DBB5057CF7905EB895
+ B4DE2057FC3CFDE594B3380636F06F3DF2CFA6BBBDC532662182AF7ACBE0F0F8
+ 390F9CC2E0FBC9B4B14A0C43F5BB9FA2C36526B2411B2B72CF35172FF0B34356
+ 5C3562650981BAC226DD6717DFD085ABA50F15A90799E504AB1FC884EB6821FC
+ 9B0C4B544DC8903FF5638F997634BDABD143243DFB99F27531A69A81AFD42AB5
+ D593322776B5B833FA120AE7ABB10B487F2229188E47CE7B759C3AA50145E77F
+ 2781A198474EB339A41EACF775CF1D01A7BEA5B305B1BCA2F50BDF02A80AB5B4
+ 75E59F5128ABDD155D7665926A0C035776151C99558A3481CF70EB9B4815257E
+ 00033A4C3160597E57DBCAFDFCD20C763ADA82B45677B81E40853399E33350DC
+ F60CD324D23BC813AADF797F6356643CD391BA5E7D0087417C148FC1D8932178
+ 4CF922F0C3E220C76A1AADA03AD75C807E736FC6CB0A287BC76BCE4B28EAD0C8
+ 3459ED6ED2861A112AD0C33F8D0B29F48A06675EFA3052DFAC06AE408F93478F
+ 6E480DCD7D967909FAE2B8B3497B84B5A71DD8B1D990546F5236CD04734CD8A6
+ AB9A0DB67B0F3DD5A0D280ED60F51A1B4A3BAB0766BE79A490A466A8F06759A1
+ C61265C33E7D9402419FC8772045317508BA1C185967E666F6C08929F13160B8
+ 6251646C72C2CA97BEF4ABF1EE2C8158265F7579AEF49A3D4F2381DB96115BC1
+ 104A957DAD1B45D37BA2D6B0BFA5981CDC11FF8C3458978131E47F691F9E8A33
+ 67585E7C86D7C69616B5AB5AA96647E2215DD373B92D7232BE2FC3843093B06D
+ 0B80CED64AD6F37B002D720A8E6A49F3385837A4BBD055A4CF0589310301A691
+ 1651104AF42DF64FB16F76AB240AB3A935DA1DAC8F64348DC29B2CB6E71199BC
+ 3930E4348C9F38DDA0C5E5A2EF04DEDC1E3E5836349546C297C3DC2CABE59E66
+ B05A356572149DD2BC4606E23859DEE5B22D6B6BB85AED82C40B57D1DD10BEB9
+ C075956210263DBBC8AE1D49305A42E02BE44FD203C10D598937DE19421B5BD1
+ D8D3DFD033FC93F0ADE94EA7417B731B52A5B5F387E70E301815E661AF2D67BA
+ 476E122EC365EBF2535D86C4D6ABEE6720398F12148D44A18B1358DE14C1764C
+ 658FAB16957B71ED74D154600F2B158F31C9A3D3544EBE7B130695D359E048D0
+ 57ACD2B4E336B69C0AC8DD6EF3823935C1B2C73C736A24B1A0B2C39B29AF80E9
+ DF30AFB096453A5A050C92D46A7D09A81949DE39E0848A7ED4BDE303B8E65717
+ CCC02DBCE8496BFDAC01E70018FE1A6BB76B74B8CFAE47E7327A9F10C7BE7FBD
+ A39880A36749F2F67BDE00BB7391D51449C62C5B47DE86411086204E5A3CBC73
+ 88C85705926786D4453E4B90CF5C82CC0D7166AA5832D249991A39BDC911CE74
+ 2A9AE898E2D90293CD8995C8B18A566FB53C0FADAA93351725CC9FB8B2056D2D
+ F50DFDA36058EC701BFDB8B8DD32DAB47F121B87C8D58D68B7753B973DC3AD8E
+ BE4FD7AAC6417EF9DEDA51D64ACE17D6E6A5EDF5D98EFFD3329E1DAC1E266C6C
+ 0681CA884FFCAB4F5DF51ADE1CC7986400046E8C3ADB55872A03623ADA8652D2
+ A3177B70885F0FCBEE6D1619760457B63D59880A2D7B7295A2EF2D08211ECF24
+ 104A3D69120143474A0E524439077D7153AF76CB1703BFC8A79F7A7B6F4ACD82
+ F8CCAD3322EE3DA6899D48BA7C69E6F3844DF8A184090DB961042C594373B3FF
+ 672813F12431B6FE256CB46CA5887A51E6A4F43D54D4C598468FB378CB91364B
+ 8519D659DF029424DD87D84D5BF642B18DE6F6F847E3094629A2602B9A886084
+ B9A9B19505CCC0749D37F878FC191D9A26D2D40A53BCFB38E7B9D44744B8C0CA
+ CEBF38EB8933226FE0AEAAF2DD3A84A75510830D47CEBA1F2D3B010F2AC553A5
+ 288CBD5BC7BE5F1E2CD19092B6CED021A460E8D88FBFD6FC954F07DAAFB12F50
+ B68A06BD06D67948AF704D1D576C4E57761CA98CCBBC1A08E59E7A0A36942B8F
+ 93833B3804F06ADF6954F451573A988D651DDB89DF954E142BD116B6968A920A
+ 85CAD1B7039F6412E4F055CA3DE0B5BBC08DD0D983DAB4A16140BD2F64484909
+ 053B119650DC3FA7C18F690B0E70DEDEB73ED435BB8308F73B34724B5DC29A2A
+ DA7515B8BF730DE1506CED81B744C48E84E94D000DDD80A3DCE49011B6D533C0
+ 20E38D9B0E617543D8BBD32BCA522AEF4B41D7949CCC3460A4E4DF66ED817DC0
+ 07C6681707A6F0240AD44360CBD00C4E99E3FF27AF37ADA3685C7B7E3727C7EE
+ 5A5F513104D924DA9E1787226B7A3832E3DBABEE4634CC650F27420287F3C9C3
+ BA880F4DF7D32A6672FB4ABB1548478756F93F9FA3A1AAFAE56654D681A247FC
+ CE5C38612125440644343628F7FCEEB1CC294FD5EA2EB5A5DFE6214BA4988EBE
+ 3488BDC3734123173E12EC7EF972F258DDCD883826940EAAD71D3466F4B1AF69
+ EEA1C4A3EB7B66082EFE28BF9B456DA47421FD102959925C97C5623A8D946FA4
+ 1D2630641C40E69E17361064B070D61824F2667E5740095155985E269601242C
+ 5CF26B12D6F5F3B57032A67302E6838E3F539A2CBB2D23AEBBE8B7EC30425BE6
+ AECD2C5A163422F03E3E864B7681DAEF923C9420A7B89FCF17E16E3F6386B697
+ D0483BB25D2B865FB903022F9B7AEA6F85BD197B42EA8B6215BCCB1EBA2BCCF4
+ 213EFA0352C554339D7C5D64B75755195E110EB815BCF42908786C430FB09141
+ 220D8D3C00BECBBC2F0005E9A2E169099EE2846BF3B5F9DF74B005287D9C569F
+ 6DE362DF0A9877B7A0216AE18B1E6ADC740F4FBE8C95B600516515C4804BD7F9
+ 5F80898FB34C4FEF8DB2E761DBD1F2D375F9BC2CD78E307559A91C169055B6FC
+ D92F8760096B5CDFF167BB506CEAF471FCDCD4F8D5FE8ACC4B0E829E66C516CC
+ B1E062C2DD5174FC32A6754C428C3098BFF3F5FF4691CFE67DEEC62D9CD09913
+ 14884694C769615B46E831F467B9302CB51D1BE1EA1FD12B22A3CCE4C261419F
+ 950BE2C61DC20D4FE7279807070139AD5D83BDED7FB8A7713E92ED851836455B
+ 8E38F4AE9AB76445EA129B44CBC4EB6F9EC88A3F3FCC2AF854E19ECF04331F7B
+ 425EB975E1D9A3D894C27BEE7AF759EBCE94C022191D22F7424A770F61F492C6
+ E35AD8683131F7534991471CE00036E4EA6E53D658EBCFFD951A24EDFBFBE0D1
+ 0D97A4D7EB2DFF35EAF7BF15AB197EB68FC1EFC603539D6D1A82EED96CE089CA
+ 807B7BCCD0AEBA6351CCEEED448E2FAE92CFF7F967BABDABF6F824C129980B74
+ B5D5DF3FD5D8894F48AE19B1A2EB638550357B2D938B1042101994359458E2A7
+ C9BE755D0A784CE024A02ED6ABFAB495484A0C832F4DE0B1618D60EA1AD663C0
+ 0D9AE92FA1ED91C0AC8FF9DC8E2B63C69742616BB269FC39E22EA194C579E552
+ 2C11C2135FC6E1F283559A7666C5F4DF46B445B4FEBC34778081221DA5922AB4
+ 4CD32C2D46D64C7196DE20E0E0D21A80A148236874EC49BC32FEB58A104CDF86
+ 16745C393743A6B77066E0B0B15790E408757EA5851AA05962355DDE3138BA7A
+ 50C8A22C4C1065C2A94CDBE93883BC7B533BE9DE020663C1E9D29A938D46000F
+ EFFD9B8165885E40401681624D6AD61D7641F3CF9A66EA332398692EFF6AC9A1
+ 25F9D867EE413E1BE6DE517463D47319395F0CC616116C1B3D5071D253DEBB37
+ DCFC43874706E5863201920DDD0A4263B31374E3FEB4D87FEAA32475193E07DB
+ 585097A925AD0787C1FB1C3EEE6D9CD74E7E8FC2615AC384B095F3D8F8903164
+ 001A431F2266289F842388E15C3FD9F18ACD615BD92EA52B8E3C6D3B0029D0D0
+ E0F18CB896D06139BF33CCE76867B94BB375C5DA0C8EEE1BCC2EA3708C44CFE8
+ 07191D79AC83BCD0BD91615CA272F69C744CA7423A95532CFFD5563A08719798
+ 92820710475352522DAA84CDB049C42E4B72CA8EAECBF90B20C47B39D1B1A2C1
+ 4A7F10D0E78A943E18206608663DA31A7548EB8E582325C1B851972DB22F28C2
+ 06CA1B037AC32A75DB44593B4EECD44C2CA1A191D3EC3C7EB7450AC79BDE855B
+ 8224145744AB0BFB22D9A129DF315B68312B1171C0ED18CE4FE0F17D8C678EA4
+ 178520C1CA5896CB0BB4E126ED42C3521D0965101C564D232DABED1754C792EA
+ 26188E859755D3E9963B867A5147BC011C5A7486E2D2043A1F8F007F6890EACD
+ 6153F8BE41E133A62FCE3686A99756803F2A00C8A3A2BC8B4227E0C06A433414
+ D7445EBFEEE9E6FAC6287A484B39EA07370F451E8B7839F1259C6B24B4103DE7
+ 24FF4397A46210EF32822CA0A950EA2A218F83D41C484A4C54D4DDE798ED6CF2
+ 97AA70173CC0A7CB4B2025C14E5C7C04A7F45C67060BC74680955CB5C3B6A38A
+ 558765483BEF239FF42579C1B63FF7A4D3B3C5E30A85CB0BD322596B0BF661E6
+ CEC091F9021F1CBB4CE77185A14F8484F24B50502EA0E4ECE410E5CBED2D1402
+ 5ABDC19506DE23599EAA689E826B9672E7D0748485F4ED3C9CEAE4521585C4AF
+ CFEB6160C630C83457430E0397B3B731B3BA2F9B254175E6BA931432AC73623C
+ 3E684C6C99FC15C48A945D529AF5A7B70350B5799353683F0DF45E3F5697EF4F
+ 0B998FAF95DCD8358431EB90A51EB24E999F43FBDCEFD6C9B35CA0D4180ADDEC
+ C5BCBCE5D82C3AC337B4862F72C2A5E61C983B1902CCDBAD972EA2DB425A54A0
+ 74B4509056A46D7C0010C3BF0071F86B1185863864DAACEDF84FABB1BC62BECD
+ B72230CE2ED6FEBFD40BA983014BD7077B2BB80591AD1DFD490B1DC674EEC3B2
+ 606D211DA05F85F79C51D1624CD01E001C06039DD5D9126F7426E11ABF480C08
+ 49424243B0446929D944C24927FFDBD95E264E0CEA8CE7CBA7A7998DF1F7D1B7
+ 54C35B831916EA26F5820A7C51B0286805336750F13B44F62E7EE81FCD11954F
+ 1FEB80CC9622EC3B51504566DD8AB73EEA8A98E50F6AFBF755D2E4370CC89D18
+ AC799F53C479EEDC4B8B37D1B38A7D7AA14C9E69C1EA26E6AF7324D44626CA28
+ C9E6A7C2441C22155D9792D2E11DD6AF030F388C262180EA1EED52B3816E3A22
+ 4F2AFC97E7C5DAC87EE95EA21D973781E1D205C750C6A8338107FBA9CDDE429B
+ DD330762A108878B8BFBD2F1A87CC02B1A69BFF95299FA1EF1986E67860C7A42
+ 2828C6BBC0F49E79B75430F537C6B375FA67B083FAACC3C2882378537B962CD3
+ 94BF537D8019FFC15B181FDC9E6AACB97B6A010605142BF2181728CCF86BA77C
+ F3187A2CED449992003B2B911F78E648381667B818B606626CBF6584E1C4C267
+ 50D5D137B5F246B93E8E7447868127539B623B9F9D95E35AB2550C413253FD0C
+ 57321A8BBDA8CCAEBC3F965EBAE5FE83CEDB8CBE79D139E4B7640EB6EC444CCC
+ F4F7D86DD12C0FCBC33A0D75167F93E66B46715C9AADC9278E272844CE6AA543
+ 7C2732569EFA66203F53A5A3694845A9289E66CE2BD6FC006ED76DB9B65709C3
+ 60A124A6648D0A61B6DF8B380CB3C2B23788C9D47E21B0E47AB4AE7E1190F30C
+ A900E8683ADC6638D34A17B6B26E522788F14C09B03DA4131F1F886F2B4419CB
+ E1FA3689207DDD758FDA059B2473EE9678A12C7D8B92DDBC86B290E632D76001
+ F9C3BE6791C240B48DEE1421F0556787DB276B80CD83E9ED740099CA1C0E4FD8
+ AD0D59BC64FEC4BE9D452BE06DAFA9F7B4BA5D80D40CB5C0A51AE7E7670DD808
+ A9DFE4E5A20F1DCDFBCFA1E878CC92B49C69C0D6170A30377ADD38BA7F1B17E3
+ B2BE17A002E54871FC1344D6F32DEBA6BB1C97B43A62F193DD96E16910E13722
+ 881C720A1985F248EE86B09BBE4060923DEEAA3174310C58E8CAEC509B3E8CE0
+ E7E618456BA85680E0E6A70971899A7763DCD7A6202B01EA9A19ED5D67F3D7BB
+ 27D9813E40B39BD62BF5BD74E48F03367570AA9E6108FCBE059175985B294059
+ E267535EE235BF3F0A9258C1A1830664EE8EEE9F0ABE253AB634AC799338A78E
+ 8FAF41895CBA5031EAF61DDF60230E6E7837BC635AC6B9C3E76377B658ACE2A6
+ 7B4CE0AF19A261A8AB45A0B69EFEDE8D67A8FCA7FEB05DB8567F6F075CAA2DEE
+ 8A2B46E6E6BC6F375406A6CF180B11BBDFD89FE4BF565725DC3A011270FB106F
+ B3F3186976955D40F93171D724F5379BA872BDCA3AF194A17F2179603EDFFDAA
+ BF41A5BCF5B1D34AEC0F176DE08955B171E0AF0AAF93C3B0AD718E330DCE638F
+ 3051A89B182BE1A30DE8C281EEF133E05EF7506636A92C0AABF2D76CC70025DB
+ 10F18DC63284B9558093AAF9B126116B6CE51BD649FCA1EE93E10B18D7B61BBF
+ 831C5CA0D60559AA3BE8BF3417E58B84AE7E6FE66D6DA310AA4A5BA2E209E82A
+ CC0E88F1BC37CDD635ACDB2784D6D33796F1306C25D9A1DE40E1F31B46656B72
+ 5A670F2F35ECC1E5F58C7DA9EDC5B63614C7EF7C2E51356EF6957BA73BE7BC70
+ 345FCA266519736D063BFA8EB6074B11804947F1AF687CA2C88ACF1E54941700
+ AD517F63842C43CC6B15D78FD87887BC47D1F523AFE057491D26103BC8CD5804
+ 9FC1CC5594CF66720A8B9A955B2A3FCD865D30EA5B826B0F2129DC8EA18B2A31
+ F45A1D21113B5C09E2F96DDA61EA5E15992913E6161140078E4DCAFC351DE04D
+ 96B978D99C847B153703548A495CC7E3D2FA7EF49F3F7AC4F8814444690D57D0
+ 52927D7BC7B981B0A2F92AEEC733B7BE4EAB860709B3B078646DF3176BFD22E0
+ E4545DE5E5FDBFD43DF8581FA2D3D7295ADA37C1DEA85393FB6D53698D25F15C
+ 605BF96C4DBDB88DB95248E9A0C82B641ABEA12A7D53190CD3DF74C9F856D441
+ ED5CAD6156C1329F85E97895ED599F7CDB609583F4D8D41BE284F8FF349996E2
+ 3173D9B50424D48F05D4344B8FC41CC898311E1B7980ECF271759521FFDE33DF
+ 4D34EB48A25BC008198F7DBCC0F24337E43F3EC61A35FFA17BE4FE57AB0728E4
+ 76A94DCEFDD370BBC3211631D30F97FCEFD4D330490DCDB48D650F9203B66BC4
+ E1E706EFCFFA91101EB5EF73C7EE2C9DDF3B2069138EB41BF5447A807539574D
+ 58CC9D84A17A082BB45AB7F869E9357638B1A7A2E011C1A57CF0B66FFF079AF7
+ 255D9F136B44C78B608DFC76E3CAD641C7124F75D0B755758E2A00DBE649103A
+ 1C9F548BCDF1DF70110B665B6450E72E7AD72D6D15C2A93D40A533D6A89CB558
+ B3FE8AD9BAFC24909687BF44FD6E46094638918C8494277DD1752DF6DC135485
+ C049ADEACD3B689A896DBC0781DD68B35C30C51E9FB1CA765698256717853947
+ 44CFD20B386B6D7EBC43EDF8FA6D73E61F9B5B558609F6DCB6C7631772EE1F51
+ 8316D74838D456D7C88894A75C02B1B45CACB4D7BF3345E218DBD77F3C22EA7C
+ D3F755701A1CE16AAFAFF773F0C4113D276EF74A436B9C5F3526B981613C646C
+ 646DAC8335017FE79FF1634BCA1DD0C53D55A5E07BA2FF20E06CD188B3F4FB97
+ D925D2696B5082E593CB1A645632AE85C8563C48F381232E5CD75529C787D945
+ 416AFC0AC58B18D267A877F6EFF392E94989479D5A108ADA1F99D24CB9457852
+ AB60367ED48ACF61C3BCECF522AFCED406B414443FE8CB27B87547A6E770882C
+ 57F460038E072402E3A0FB70F5B6F366B21B140382F037DE7F6445E208546DF6
+ 4D0D0E23C4CA838F31FF1D8475E6BE591FF32F943F26E214074EA7DE23B9DA22
+ 2F0CEFF34DE4FCAEAC9377A0C777D1F9410ADE9340E38F5A22C292ADE240C268
+ 3C22E35BC20C6672FE8DBC1D8A521ADB1D882C788D1950B8F7663D1AE7A7A0E6
+ 6FB7A34823044F74A3818BBC1F35F6824D3C5EDC96B042DE5A13A28DBEB980EF
+ 1D050FA3E728FF1EA8E5599B144C720430D214F3DE9F0EDE1F715B4A59240DFF
+ 3521255B07F4A1E3F44D8C8758D8DFDB150AC8FFCF29A4C1A5359B46A00B2E65
+ 3F07B282890C9DA4970ADF0DEC8D0EF6FE40AEBC5388CD269BBE2C053C07E869
+ 0AAE8A604D6664A80384C39994F53A6B02AD0B18ECB9A88E38EA044FC4FB62BB
+ A7EA285A8C0A16840F800AB3845D69E54CC3953F5A445913C2D949A226F23855
+ 65942161E9B068353758385517D76589B1961D62862AF3427BD43EB28D05B73F
+ 3457BEEF5E246B76B60414307E6DF3BB1710619CBD84733911E58CCB28096362
+ EAFD16AD13AAEB84FBCAE311B21E64484E7CA0D448BCEAE5CEF7FA89B0B2117E
+ 6E2DC192E5B2D618A3E26C0275ECB33412B87A44ECF36A58FDC597E7C8122900
+ 39E791EA49CBC506DADB0C8494DECAF21868173621C3FB2737E469EF88DF9831
+ ADE8BDD98C1B4F0F0E2F1C7EC1707DC35B2B52343157003ED1F40457DA1BABCD
+ B2FEFD123E854E22070D33E30E1030E3B360C3822CEE6D897E0B67AC54020748
+ C04DB292B2A47CBF953EE24F2C6EFE8FCD4C4F99329F89A62650D9011783CFD0
+ 8A33F47F3689079D9F4E02CF9821BB284944973A014FA3E5B1C452E20D8AAD26
+ 366FA43498989E9A3BD658DBB80D1A2D94F0DCBE59B34B879A75E8EBEC043EC9
+ D6A2DBE6BF67B828F661BAE770D19D475B3882AB9F54AEFA2A829F939FC45FA5
+ C44B1588B884FF92381F20E9A2797782616DD1922FBA5E7AC03EEF9E04636B49
+ 94E152F372714B4C35983000645CE5F86BC3C200C89D500734D7BE4E877F8A66
+ F3FF3F0BB7EC1BE44E0C2E81CDFCBE1880757E307B86A81872B5E23AC43A0565
+ 7EC339F7B401BACC873FC8746D73A39594F4B4CE0B7CE9A96FED94574D5D5001
+ 05A12BB0D1408B4556E4C2F6EFB6C97AEF6738F33D87F31460222599B4C62E77
+ 1AF1F9136392CAE8DC3F9353B91CF105B00BFEE0E34B9CF3A91157A1439AA086
+ A7F537035FFE8B144790CE5491020A6BCA377E1F63153FD0BE81D7A6797D8C70
+ B9DFA0AE154122CC5B668E34197FBE0E7C23C4024BCC881A2DBCDC5D04E80486
+ B5FB8FCEC8534667FFDEA0435A6493E37F6D5A1004E1CE36157EEE0C481438A5
+ 83CDB157D782B116301799F6E59B452ADA2144DD7ABC19A3D76A6A253244687C
+ C575417AC5A2FFA877871C622CFCF92DA81C5B9831DA06F36D254E67444FEBFD
+ 694D06CDA60B51FEEB6698A129ECD36CBB1C73EEC9B752B2B63D5DD103CA35F6
+ FA48507F4C4E532F5188EBFD3FD110ED27B452F1A0C91711C35C72B1586097EE
+ 576202DD32DC44A198F908929CA09A0C5F1FC221D4B7F6B8BD06072704161F45
+ 8D9E8EBFDF265872DA77B9049F5AD30E4CD676355B2633AC7AD95A8ED0625A28
+ B4014B581BDF3A00B3513E40201122B5F8761F6EF6D6250DD56C339DAC5DA092
+ A8E3CE464E072574BC9E07966AAD0222EF3B78EC96A2A56DDE9049F9E1157AC7
+ 3F7C1EA452F87B4FE9E54A5D3FD38BD671CEBADAD2D0C765B4989F21F6BC5BBE
+ 0EF0F2A0F59892B494349C50946900CB015FE0AA506FF5E3ED5D5BB74A5F38CB
+ 1A6EDC9F3F361AC7133B548077A6E2CACE762ABD8AFB7ECA5839CCF62AEA6C38
+ EBC9C4DAA415A0001E7E57635A5B53B9151C80C82A1CFD23DB2E0E13A0B29546
+ A805344FB00D48A1761A9726C08973E190F0750CE3D7A15572F2DE87E36A0FCB
+ D932A4A08348FC9DB9DC3C04DD07EBAFE6A20F48BFBD3318BCA5CDD4865A59F7
+ F7B925835B871B318251F2449FC5DC4B6BF7360F5ED25872678D6AB00D4376CE
+ 6025F01DF7384C53C3AB204E7AB36F55AF764AB5297E8ABDCC9A8301BB41F151
+ 1F8D853BDE3E14E50C4DB9436D781D26284A2F38E50B34F050D9BCE3580FC6DB
+ 270EE9049CCEDA3E61C44D329A766125C398E0CD2BB368FD569480077C0436D5
+ 0A058DE00AA75D53BD92C548AE2B5A4108C2EFF42422A3E85C60DA4123890FA1
+ 3668B1E397AB6E3D9150B2B437B66AB205B2A4D3E218D832A05769164BF8DE10
+ 1305DDBEE9D00B5BAE7FCE4BE1E2E17FD2007389D0404EC79CEE21237A7F6D81
+ F793EA9B2E9CDF826291B0F29E21EBE890C6F8C5D9B37B13C057B8FE717E7909
+ B3BD79CE34E923FF2AB166E7A75837C68A4CEE8B0F345ACA63192F3614F1EBDC
+ 6AE147519B19E17295B38ABBFAC107DC39E4E76703E8B764BFC802CB744F489F
+ 969B990A3B53406316D0C2DF03238074F54F6776AA7D2D5C37ABC58FDBA8925B
+ D2DD1B78E97B003B25B1E08FDE56DD359827836E88818987B4BFE70B9620913D
+ 3469532EFDBD321BC32286D60A598406E906EC9B154DDC0C7F5966B05E127EAA
+ 8C66D569B90A3362F92BC74C1660346A0CD3E829D999AFB22718EFDAE26837D4
+ 16D1806C49443044F90A0A093CF6267CF2A0E5DE61082B778A511FBB01DD482F
+ ABF3DE4A317F6B8D9365279C57A474F4FEB6B828006F21B6F05A51E7F56DA007
+ 76F5BCCF2EC7BDD3F9FD7ADB75D2D5C82E5AE7B77004CC61A62E101EFCAC7497
+ CA1E0B253773942A221F3AFE212ECEF58352133080F85C35EA6EEDACCE2F6FBF
+ BFDAD6764685A145C65307F5DA888AE7377876D04D83D739A5A21C3F11BD4B06
+ E2E85A303801F80E23B3C949FFD7E20FAD0008E7F828D2D5F5FCCAEE146E89EF
+ 8AE567F7EBDC0EC6A3F732747F871ABD910E4FCD7AC7787AD373B5BFC303704E
+ D0B09FABEB55014458E3942D26B7BF43415B753D465B1CB81BA0FFB53A3CEDEB
+ F712C8058D75AC686970763A65B47D30B253BBEBAED01A7CF07597781E01F19C
+ 2241A10E4BAA7E6F886ED44FBB047EB004E3B5854BBF9CABEF3B0D1AB0498023
+ B50AC8F22645B3A52AEC2D91603ED902DB63E7C1E72B2C6D7BA0E0655E9AA502
+ 7582D787B70FC289F410655D18A2BF6DD7DF0B7BD3434A929ECD343E21265A83
+ F55914261385E6A5FAC3C093CBE7353B5DF187F5A5917A67D81D635371591CE5
+ DC3B82232C9BE4A69620CAD1FC96EC837B4F20B1EC052C19BDA82798F144C61E
+ 181F68B2CC9E2B738D7FE189D9F9B8A370DA41142B303898997A19A4F54B96D4
+ 7D51340F0082311D7E4A6C9DEFF8D5E460F28A0110429BBB9DC16B8630B7D20A
+ 7E86D5CFBB23B5C8304361E3C98C3DDE3F988507FA89E3AD63F701E594E46615
+ 05A51C6A27CB4C372546E3561872DD5B44B299EA4864FB3F622ED41CBB41ADC1
+ 4A21578387A57C774F2671B343C6F2CD5E4C61B9C0BDAA0C56909C9A7816C72D
+ 76C31C91B415D3BBBB971EC2DB5403678EFAEE054555819F111ECBF00FCE0F51
+ 3810A4F9953D0CDD72861A58638F9DC088D3A42995F6B229754CB61AEBDA4574
+ CA8550A00B6EABB1F6DF9168416F7C12DFE7402535A3BD4E19A980DCFE84F7AA
+ 967CCDC9F03884F2CDD47FF5EA8034E5176133767C44A1C7227BAFE8F7ECF8E4
+ 468B7909B17640419D9790966EE7A192911124D6398550A3870F884A6F6DF71F
+ B2965487B01CA3BC282F31B192681839BBB1D9B5DF8AF5D7E7E683E4CC42A3DD
+ F38DF9DE8851234D2838D55848339E2131BAF417D8EF6736204FC7DE4D1E3B22
+ CDBBE1459D7F15F034DB2E4E8AB8C8890ED96A274CBF2D54C1FE172462741C7F
+ 7FC960596A1AA00E01CA6EE6D1E3DD9C646EB6E261DDA3DB00C5612D2D12AE7F
+ 77B7DF136C2C8BBE80DDE2E389B08E5956BC3A8FB134ED83474535B4A9084350
+ 2164C54CAE5BA1F869D63140EA039CF86518A1024C5408BA1EFAEECFE0EAA31F
+ 9157C5667EFB2CD48411D59EC9E676AD49709B4DF3067FAB4B4D935845C6C662
+ FA7A78ABDCBE02B654AEFEE4D9362E64A81FE0B009BA846F820419007A7F3C1B
+ 55F7FB09D3B117E00A73EAB9C233CCF2F9D614B35352807102FD2100AFBA3196
+ 4E701C7FF590590383901D26DF6B8811765A54CB5885DEC0D12675CEEDD7BF67
+ F7882AB92EBE5204741735540600133FC261D74606B0BDECAD6238A460AB1017
+ B23E2BCF7A5B497808C532C2F88192F157A482D37E442B296427F41CE938280D
+ 9607DE48D96E245E189622E102895EB989975B131523E211E5D87A90BC254F8A
+ D1597C86FE535BB6AED4A776B53CDAB2413AF790D708E9DA8278F3E661D2364A
+ D644AC8975BC7924AEEEE217342D2B5F14CECA23108C7F583771E5060301C7E5
+ 4EB345704A5422FB1663FC429C797E403F82F2CCD90E26A22D2107CD25066208
+ AE05102104494B3838FD32E0782A504D9C64467B4A59011095099C70FE907849
+ 532BFB8A68532E55BEA54E49E599D97C64A2F7366B68C88CD4778323D8BCB249
+ 2EC45C556F470E09A788A89094CC17103B4CE1C91572B54A581B2FB3774D15C0
+ 25C4E6A7B5DA1BCB03FF88442DDE4736322CB261BC9A5E651CE2CB5D4C914732
+ 3CA236572E7D61BC037AFBE81951DB512028755698D85B271FDB464A0180A589
+ B3161526DD21F489708EDBD1AAB3BD7C567CA82D7657E688EA068FA20742412F
+ 5E9A870DD0E11B18C6E5E63FA45BDBFD28011269E3B1470E4ED5A7C311605DE5
+ DD1232A8E1146024B2052765BFBA0E31056353BD30D9B6D3E98FDEEDF8227DFE
+ E0CC43F1EEB29940FC46A49C48DAEB04239E49A7FCFB3E820C2488E38EDFFFEE
+ 4F1801F4FD6182382AF0DC07977DF342A27203CAEF12916E91535FDCFD152697
+ 46DE27DA8442D59CFB54EA17AF12A061BCD9A208CDDA218724E183D853AA4DC1
+ D976E278982395239C2F5B082453EEDE32797ABD94DDA46F2EE093F2AF8075BB
+ 0D0D72969B5FEC8AD457CC92876006EB31DA2B43C7E2BF532503466E9247263C
+ 16D558607F50CB0FB3ED86D57678DD933B4C6A2CC5859920CA63AC8849FE8A58
+ D1BDF2D1CE331A14219FB8ACF09635EB7C7D556146B5B20B8185ED6FAF88C3E4
+ F2E0A5C76B95B44CA566CFAEB829FB6560003FA935E30EF3D8FA1D09E4472697
+ 3B7938D96F847447153F2D3CDC512F9F1598DC3270FE7F415636D36BA840BC62
+ 00BA683454E88F6D2EE428CE6C685CE3F0E9D2954934C5CD36AB2845403A7FA7
+ 4E9DE30C3CFD463918786F99EAC02A6AEF71A43D3FC33EE4C2EE6C0848080B47
+ C3AB2884370266C71AF3E4BE4963B96584622C9F3D753E752A4D1A375E9E8184
+ CDCD13EF94D3D5816AF133F5214F2413E1E726659CABDF5449A12FF4DB3431B3
+ E720EB3E7B7AB887AAEC0A6019A30ED25034882BFB14CBB1B6A72A5EF2AAC934
+ 92F804066C97736BA42B69C7A10AD32338D0B295D24EA3968A61EBB882F43B8C
+ E615788BCA1DB26E5C2084B45F16EAE18EFF27451CBB1A12D7FF706FC8DDFC21
+ DDE42AD28FFEA5478AE4B4539056CF3158EF73484BB5BA049F4CA10C5701A8B8
+ 3E58DCAE7F8648B5568D85158EC3CBCDFFF89BA00D71AA01AC5394DAF2A1D78E
+ F2CD545FDCDFCC47EE18ADD7151E2D44D850C62BAB2E63282CDE6F27DD3A03FD
+ 88714DD0B41DD667524BD058D88C13E996F652679C3711EAD83E4A4B764A8F6F
+ 3331A4CC7C010DD16837838FF7B7CEC065D38039055CCA58B57062E755AEE1D2
+ 6602E3D48C39068985F3636FE740FF3E1113D7FA3E7C2D9E84B82DDE983E4C5A
+ 2980A2D59D6F8582E2392E12D24C30D2C4DD29194D4788613C96F4693CA60AED
+ B60BF11FEEF252B9EF9AAEBAFAF703247FF5D0E87228412442F6F304FDD842BB
+ 6D09382702860744264F1791A374F1F0AB002383EE009702BDD6DADA01F47542
+ DB7D6530E96BF0EB7FC779F797707F0D2C893C48E2C6922E23A24C3F27207FE1
+ 32DF6EC29E90F7CCC93F8C9B2881E7CEB0A144DDC841E7C9827EAD5FD95449A6
+ 5B6BDDB64CFF9A96B2A29C9D0834B02CCB3DA4E8462F6B2575100C66D561E139
+ D3453FD6B5EF2A94CE8E38F8DC8DA1F4EC5E81D50DB0CD12DAA3BF3954F0C0B7
+ DBCC7EBBD2F6FACC00D9DEA4D243F96DE218ECD6F5D58FBFAEC2BAFCCF29F5C1
+ AB6C7053CF0E8BC8CA7D1744F11871AFF699CF7C7997C84A8A47833A4091ECF1
+ 56EE5525BE1013F871B13ECB2582F77C6006AC227F71C45F5BA389BFB6A73B9E
+ E7048D4F2960F770A376672468A9BCF02B6B6899EC4A95F101B90C248AE47664
+ 7C9920A766AD328B9C8A660EC2792AECC144CB076E6E7CD823A19B8BC9936266
+ DA4AC47887A23CEA762F63DD9D065B5474EAC383881E6524A200F8E73802162B
+ 8B5409FB21838C2F8B4E2174E4A7D3D683DE4308ABDA4A990DC93DD17B6B7A12
+ D010D281B26012AECF58110A728F2B018E35925790CA9C5BC365AD52D348A3DF
+ 890BA8AA7D6E2A0F65EBE47E69A213804CCB606BB268FEB22E11AD0C91457907
+ AC8846B7460DB2BC102598BBF174E0AEBD2D87588745C23F5DC0B1785A637260
+ 75F0C00DCE62FBC220E12E19A4D42D97F2482F98C4B9ABC1FB449E6B8042FC1E
+ 4EC036F3B9FE63C8EDA92F34D9FB1962E00DEB6DEEC0B6D7B4065FFCC10B47BB
+ 57DCE2D906A5DBD010C2DFDF0039924AB5D17C6CB00679DC9DBFF3ABB031E03E
+ 66BB7626B9881F30D5518CAF72326FCD0F199CDDCD7C9606EDD42EF1E16327D3
+ 4A4592FFD8C890589C10E562C4AEEC24D65F0FD1E056137B65E963D79322BCBA
+ C998FD61E0AEFFBE2102984C6EF0E89BBB57161CD7947D7508280B599D16A274
+ F8009F9DA5E1D5B9643D06B7258B31E5CDDFE95E3A768DCB3EEB7954A63C3ED9
+ D5CF86D18312019723D24CAA1DE12DBB677EC3350275FA21BE527ECD9E872C7F
+ 49BB8281A6F864D0A5EB2D238C512034DE905EDB8EE41DBC6B04C6F5A448B492
+ C0CFB8B6E5037CAB1D5AB336C26EF75BC84815FB462832B3FFDC6F029BE0D43F
+ F76A57CECF991D34226D391675C62F7316D23397712E6FCE8C0446A4D1D8C75E
+ 1ED9F84B31AA134B8950904E499B73EA305F3531A82C78131E54752F6335B62B
+ 60D0EB9DD7E213A20216DE39702681685D005FE32A57C3FAD0645483FB6C92C3
+ 9018DF3833FFAD7B514009AAD52272BB9430203B0C99D3A56039D2C5669CFBCE
+ A1AFCBDE1F552F20F2FA0F2CB9A2AE3D64CD6E490290B19C40CFCBFA25C32F59
+ 2B1A2C264D53EADE0CF4A27EFA03460A505BECFC9C1E82ADC3EC6C7CBD2BA2D8
+ 2A1AC271A79823F5ABFC6D13F5FE4AA556A89243A9BD32BEAD91F3F4B763E899
+ 76B329FC456EA265639DD6DAB624C5BF3A744603C72CA40778C498D548B3AC5D
+ 4F511645CA0AA81AB18D02F361498A6A5A1508B6712E0E30C36BE168947453FF
+ 0F91A12F3DAD95414BF6550EC3F047E5AFBDA1D6791D9CC2C39307781F01B065
+ 867BC76A23F50E75759A2DF3AFB296C7741925AC511CEA0A601F322D25C3EF55
+ 88D57D639F3D07554803EB19DFC3EF8EF74A4C5A15C43589A13F4DFB2E6E50A2
+ A97FD95354A78F4B69CA17E8E231BDEB0A276E8E6ABD21E94F1369DF3AB3BB19
+ 396EABE6F64C69B6E527C051967B46F62EB93D2D18BB803CFE8DE47569226076
+ F7C5F9CA27EE5F296705E1D83CE54F0F1EB43663E8B1BD7D8B93C9AF41A5A2D0
+ B5546618E2692B3A29976AA52A66652FBBE8F41F3FE1D112619208BE5DCBE033
+ 0DC68082E6AD1CB074C18AB2D86EF085739FB3632625F7CA460FCC4EC1D46B90
+ 5F3F256B561441A126986D64BB4F6069501CA6D11E78128B0F3207B9B36F975E
+ 334F4CDC863ABFBF171700482AF2294DFC118E0C5E7D7EB74E2099F0B67BD804
+ 5AE4B591B4511EB1C34F09A93C412FD377465A83043F68D1B0029A63118E9C66
+ 88845545DE554D73A125520C4F91EE25EB79E3EBD80894B60442CACBA28A3801
+ EB5E501BF89A306D8E2FFAF5F8A300B5D5886A7C43F6E819808F02AB8DF55E47
+ 83E7BF514DF2513462D234A1134649C5D294F22134505151A81F4D513C5DA38B
+ B4594EBCF382C14AA7217DB50FD8E0CD0A28D94374CB62F5245CFE858B7CA420
+ 22FF962F89666E28D42D52A14AF4C02907671CA7990631BD97C91C788CA34E8D
+ BB9439254EDA1788A4F397EEA1B8444DD3085D4E365728EB524CF7F4B79C9D79
+ 84514A40CC21F3119E825CD9EBDD329D2424E35715413911EAC799AD6BECB542
+ 44C85224BFF649EE6C734F3E242941A69DB5A5760A113FB262716065ED308FDC
+ 9A25DD36FAFB46015687AE5E936AFF2109FB66899D59333A59581A64FECF6496
+ 9B1BB32B2D4641AABED0D4F5312482DE7893294C7D61AC376AD03A7E631B0217
+ 6DABE5D6EF00A2C5E9C452847F614AA210AAE151AF4496D83106C69AC08D0D2B
+ ECA3BDB80836831240EE515CBCC0E58A95E6B494A28A13D4D0D06A0287642D6E
+ 54CB3D4E75F0B9ABBEB5B1DF1F681B1D53B015BD516288460955D909CD3460BB
+ 9B2BB6B87645C82AFC857A522256E578187DB83DB70868907A2D69046E70360B
+ 72FEB50EB3CB8689FCA18B905284B4CD368C5AE621EC5CE1A7B211524C806815
+ 57F4B7F57C8A93BCCD8BDB241A6782B6A17A668B0D0C5DE008D5FC6A6D299B37
+ 22C4DDC414A28E5B8CCA8D2B4EEE9E82C6773FB2F4393536A28D3B6F30CBEE46
+ 43243C1FFF70E68949D600203027A7A1FCC865B779A95ECC3A3CE7AC0C8111B3
+ B16FDA0BCA93CA691EFB3959C3550C3ABA64ADBFFE19921EAFF02ED1F9D06919
+ B3F433BEB4E4D60A946FBC4FBB7CCE594E3B5A82F64FD5BABBB0B62D9ED9BDD1
+ 71A3437B950AB286AA076DA2500E52DE48C3214198F152C7402E5BBFD5E09E32
+ D0D176EA96497FAFB9AA7D5723DD110BB43D4964340EC46B617349017185EB0A
+ 7EEE201BBB8043F6B0DF0DF12AA35E69E7AFA68DD0345F976917F57B0C95D91F
+ B383F0FC0DE7DDEA424F0F51A3B52A1738BD939EEDEF7C54EA614D1D5AE9D35A
+ CE4B57A71BD7869E5FD7A1076ADFBDBF4DD6BD252DDF46ED8247E73E6CF9A369
+ 316E31EA6C8A808CFE0B6ECE6255D7B62FC57F2558291C02F87C64CF14C0A76A
+ 34983F90A1AA549561124E71E25C842A74854A80055C9A30294AB735F0D54E17
+ 801D737F10AE6BBCD96C366A535157813B8E9D0623A39EF0566727FA44E9E2CD
+ A3D88BB7621DB9F4C40A3F3E970F74FCAC69C3FE21D16F544C76ECAB61BC8CC1
+ 526050B18FF48CC96876203973AF98A96AD771248675C675D250367C8BCB4D20
+ 2883ADA53DFF07B9CD6049212345A490281C9384B7E1B211DFE69404900A4A4D
+ 6D7C0537983D08D5FC1E4AA0DD87E75B3C9877F3DBD2CB3417E16EBD4797A279
+ 432AA651C8DB9710E6A7738809CDC1FA19E9A35E34AAFDABABF92EE556032DA7
+ 734EF206D3E6B5AFEFF14F6F86876384B226F0BE8D7BF48AB3DA8708081118EE
+ D7CBEDD8C6EED585425F6CBDF7FDD72FF913E6AAE37C68CD62EABFF570665EFA
+ 311990D5CD5BFFBB0AFB5D9FB1835704E5799C64FE87D93FE37B1D5321CF48D3
+ AEBC37CB421FBB030F102673C559B46399613CB422A9C86C34BEFE1315AA5DDC
+ C7716110855AE7882FA5A073A6BD9332E64019C5F0F991BFB8D2C89B83A1F99C
+ 63F2A20ECC7196BE607FA54BC4196A7C3767BDF0D832D05CF5308DA303AD1EAB
+ EC467E6B8F33FDF10EC760E8FCCF92DDAAF3A73BE43DBC6D7851BA05B99B53E3
+ 00A813AF1F1F5E243CBB8B727DB53FFD6D3B8E972AF909CD29F61212FDB6B18D
+ D54D7785DBFA11EC1366558FC9F1E0EEBFCEBE7B197F701359B3A7B0F03A273C
+ 48798F5B6A88746BB4E0776ADDCFBE7EA55F6704DFE8A16887EB435F9F773137
+ 00BAB1FFCEA7CB30A8C527620741EC5A309BB016DC0498C663C09BF321B25950
+ 77430B674C85CC32B2F385AB58D89FE8E87FB4A8041F12558117CE9EA1C57150
+ 201F2E15B17E74B7C26C38729688E2DE09CED9AD41E296A5AE208D51D7032561
+ 6DC7C61B4F2194F978B70DD8A327F8E4D75D529F2DF5891640DA6AB73C33771A
+ EB6AAB00463C97F3E26AE3F2B31C71C373D407A07E56E5AF32EA1027776A8CAC
+ 05E6BCEEC7330995D7C14E2FB19F0C721C5FF2D36FBDD8A0F0C9F7A73601F865
+ C6CAF6DFC470E0148E52CD2151BFF60997ACDBCB1A38E3F0968D5302242E6F1C
+ F1D02C40703E1FA65EBD4041009C4484BECCDFAEA7C8CD8A07A75AEAF9C13794
+ 2B56E800834FEFC04B80DDD7FBC7D6C98A1D0231C96EB13FC403C86C8817458F
+ 625EFC48B5338CA8C342C7A38F011C88EC9BFB4316372FCBAF3DF3630E1A237E
+ 793F96D10D1FBE03F660A5AE6AF228AF1B85F9EE93DAF9AD3220B4E2C01105DB
+ 902B6ABF4CECFCCCDDE83DAEB19ECDEA69CD3E561237E3B5C8418FAC5BFB9EA2
+ 17881BDAE7612B88A8460396FA72DAD0BFB93FE3BAC18C410D815E070DD3ECFA
+ 83D9949D61E1D63C1A2FD1F08B5C6C2E355B1681AB32C8C9B725DC10281BCD6B
+ 335F63EF0D29A14AA148E3C069B6AB8EAFF28A7CD1CF1B5821926EA8328C6F48
+ CAD1ECAC7E8A9EB25B3DA657F1244C023C46BE69A0B3569F44D6644584AD5607
+ 089F49295124213943F5A8F9C65CB18B3E2AB136D40D1F797C295DD435CC047A
+ 151A41C373ABA99C5EFA03938ADC74AF7981DC9CA62ED4F42C73F86AA56E8D81
+ 96C97E60B897B1E2D59A45626D4FFFA1A8A8BC09AAF344463FC67EBF6B9CBCBC
+ E2469CDA26B12A625C93180AA6DBAF04A8DC3F47D9115407CCA1EFEC7A429982
+ 84342755297909AC8D1C9777237BC660310948BC28787AEF67B7840CE610D3E5
+ 49D8B584FB112F5610C286E6DA34041E4E6E77B2B63316EE3F29501EDB87F043
+ 564CABCFDC78408ECC09BAA4FE690E11DF640AB7B54692E616F783A4F98EB6B6
+ 400B14F24C478E74D9E9AF09DA8A0649565A77DFEADFAAFB53890E3AF9AB325E
+ 1E95AD1A0FF957111165C4EC5B4648CB7E1FC942A9174DA4090AE8C79FE8AFCE
+ 87D88E81E702A8FBEC6171AA6843FD20CD446796CCA12B61B1A8E2939A92D8E2
+ 1F8EF0CACDCFFE0A95EECC03B3D3C9449F6EED1CEE53F79B763E4D73049820AF
+ 95D82191134FA0259D6F84688DDA9F886FC0605F9574C0CC1F6E1498CA4E9E8E
+ 943F4FD5DA9B46BA317EEF662081474B80E3BBE03645EAA777DC8FA2680D459D
+ 53D6328C44229395C6BE551D7DFB87F79FAEB24AE8C5C4BDA23069FB1CB7BB03
+ 5BC01715C784AE5DCC9169B3D96F5AF258FCAC1DEAE984817C166622E64BB8AB
+ 64981F03AA36E34188A3AC5794482A00E2CE0F17805B57DB33A121B1A214D0C9
+ 2F7F4CA8025FF6B8117F1A531465E5094F585A68D7B833ECCF8E59731A7C371B
+ F5B0A6A4C3261E1B02E4C2FD24B227FE19B957A12F27D0ED5E3117F66ABE3AAD
+ 69CD5B1CC31D52BA2A93DD668A0B7B548806848A87CB80E15E81A22295E0C27C
+ A57404BD178E068173423D06A270ECB945ECB9C6B9A5B7DFB82EDF3DE2ED9E9D
+ B29184F1B8A806FF7BD34407F8E2E59FAFFA9B8FFAC3D65EFB7E3D21730F1E3A
+ 1B1B32B7818740BE07CDF51294894FFCB664596EDFCF0C5857C05F6358A58ABF
+ 3B54976C8D0D20E0B81D2DD91F286FDA86B9F4ED900F472F9390668E9B6CA918
+ 4F34B0284992479717F2CA4435883F506E67757CB8B9B376F6FE1B67A9C3B48C
+ 7B8EDAA12C819111DAAD0F0744FE5175250BC0E823F3B5356B607B8999D2E90F
+ 998471240B57DE0E2DE5DA56E1EE87CFFD63C4C896EAF5C300D15D08D5175C99
+ 0C8923FB3D60ADF36D192194887D76618775521645BA896C9338B06DB2591EBC
+ A82A4CC7F2C58CDE6D12AA73A3FFB3BBB0E8C93A384B4EB889C9021102463890
+ 57772AE440B3C70BA729D00F0A386CD8D93F617DB56971DCC35B4ED0FE80E0C2
+ 8EE27D0D77A9C92976DBE29487BD1AE89A654B4C3E18F38F724FC9487D60ADF5
+ 519C906B8968E56BFB4CB3351E3D5A66E7F17FAE2AA9E1640CFE827FE45EFFEA
+ 162792129B11326211B1816C7734E428137C3CA4FA1B1E78E6146667D04E8182
+ 7D3035043823F9420C08E84BC0ED4D081B6E69D0AA179F7E9881C6785D37E96C
+ 2173D5418878BB89B47C7D125D4C6A0A81C520E1B299A5A2C757A62A2ABDCCA9
+ C509FDD913FB8339812F16A2DEC8251E03D313584BB4329D8A2DAD39E5F7797D
+ 5DB30178B8E94782D9D0909A7EAC25B3FCE8272F749CFCBC905DFA43ADA93856
+ 14DB222FF0949BBA825C021240C4769BC71C573DCA80505750EB9032272001E1
+ 46140A1B53EF67791080F444BDFF6BBB30B1475E7F050DA75E9E2063E706AFCD
+ 11F2449FB9CCFFCF107298D0074A5FE5784D030A2378D6098D41DE5D0E84047A
+ AE3C11FA15783AE23B2CEB8C823D72D94403AFFE1840F4E70F9B410BB05F19E4
+ 7AA8C7F1049514DCD9C8410D81D0C80B468185A388DCAB9260C0E3C3AC30A373
+ A6640EFD7BBD2E08E5046119D7E385CE8D742DBB0DDC10ABBE14EA39BF8606D6
+ 8F206566BAF391D9B916B572BE8BA016672ADD60D4B428AB01C96A8A70838ED2
+ 15BDD8DCF0194EB9CE40BAD6E96F5604E5B689A5A25CCA867C473A739DBD27AD
+ 4FDBE64A9F489BAE2E905A50168457339FBD628E404A799109F6E2692BEB27BE
+ 2F9B0275EFC208D8DD13CC4372530763D1936754D5260DEDB161D925DFBBF4F5
+ 9EDFFAB014E463DA53582413223429D10391E2314E9D371DFEAE2C854CA525EF
+ C5A05C3D7EB367878F0CB4EAFBAFCCF0C7313FC09C0102B437C9A613847ED2A4
+ BEDB77139B8C36D4E40EFA00E9198FDD45D0E2029503DEABBA1246564AC4B2DF
+ 6941893CBCA18DA44A99A3387B36CDAC99E44533936DADBCA7DB2BE6C4119099
+ D2A1949BD59674E2AF5A098C4387B3E54A917AD77999C6E7C362158F07B2FDD7
+ C5E7699632D0AEDD38E5C0151E5BA497BA220F51A87BCA733CD9370798E28A5F
+ 59EC35B6390DC6D45B3FCC966FFD641DA6E4F723C44990F48F41E5322FECB6FB
+ 70CB14A3D64268EAAECD030735098DF6C979F78A48985DC7AF5D92EB85EF4DD4
+ EA38581873D607F488E327D891C98F03652A6AAB40A0E03D85D0C7CC96987B3F
+ A417A40AED74D4781A7C9FA3FB737531005052178333822FE827975E2F98B726
+ 28D60EAE117B06CFF3D480A734BAD742
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ %%BeginFont: CMR12
+ %!PS-AdobeFont-1.1: CMR12 1.0
+ %%CreationDate: 1991 Aug 20 16:38:05
+ % Copyright (C) 1997 American Mathematical Society. All Rights Reserved.
+ 11 dict begin
+ /FontInfo 7 dict dup begin
+ /version (1.0) readonly def
+ /Notice (Copyright (C) 1997 American Mathematical Society. All Rights Reserved) readonly def
+ /FullName (CMR12) readonly def
+ /FamilyName (Computer Modern) readonly def
+ /Weight (Medium) readonly def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+ end readonly def
+ /FontName /CMR12 def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0] readonly def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 46 /period put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 87 /W put
+ dup 88 /X put
+ dup 89 /Y put
+ readonly def
+ /FontBBox{-34 -251 988 750}readonly def
+ /UniqueID 5000794 def
+ currentdict end
+ currentfile eexec
+ D9D66F633B846A97B686A97E45A3D0AA052A014267B7904EB3C0D3BD0B83D891
+ 016CA6CA4B712ADEB258FAAB9A130EE605E61F77FC1B738ABC7C51CD46EF8171
+ 9098D5FEE67660E69A7AB91B58F29A4D79E57022F783EB0FBBB6D4F4EC35014F
+ D2DECBA99459A4C59DF0C6EBA150284454E707DC2100C15B76B4C19B84363758
+ 469A6C558785B226332152109871A9883487DD7710949204DDCF837E6A8708B8
+ 2BDBF16FBC7512FAA308A093FE5CF4E9D2405B169CD5365D6ECED5D768D66D6C
+ 68618B8C482B341F8CA38E9BB9BAFCFAAD9C2F3FD033B62690986ED43D9C9361
+ 3645B82392D5CAE11A7CB49D7E2E82DCD485CBA04C77322EB2E6A79D73DC194E
+ 59C120A2DABB9BF72E2CF256DD6EB54EECBA588101ABD933B57CE8A3A0D16B28
+ 51D7494F73096DF53BDC66BBF896B587DF9643317D5F610CD9088F9849126F23
+ DDE030F7B277DD99055C8B119CAE9C99158AC4E150CDFC2C66ED92EBB4CC092A
+ AA078CE16247A1335AD332DAA950D20395A7384C33FF72EAA31A5B89766E635F
+ 45C4C068AD7EE867398F0381B07CB94D29FF097D59FF9961D195A948E3D87C31
+ 821E9295A56D21875B41988F7A16A1587050C3C71B4E4355BB37F255D6B237CE
+ 96F25467F70FA19E0F85785FF49068949CCC79F2F8AE57D5F79BB9C5CF5EED5D
+ 9857B9967D9B96CDCF73D5D65FF75AFABB66734018BAE264597220C89FD17379
+ 26764A9302D078B4EB0E29178C878FD61007EEA2DDB119AE88C57ECFEF4B71E4
+ 140A34951DDC3568A84CC92371A789021A103A1A347050FDA6ECF7903F67D213
+ 1D0C7C474A9053866E9C88E65E6932BA87A73686EAB0019389F84D159809C498
+ 1E7A30ED942EB211B00DBFF5BCC720F4E276C3339B31B6EABBB078430E6A09BB
+ 377D3061A20B1EB98796B8607EECBC699445EAA866C38E03ED7D4F3EDBCA1926
+ 2AF6A41F67AFCFBF3630C943FA111E4CCD988A7363F7C2B75EAF5830B049460E
+ 0D2B337988F150B9182E989E7750C51BA83DF37685483F86D1F47478883F3F6A
+ 4B7F768DA5AA89E8F163029ADD4A9209DE8A4F285766C06EA859639B92CCCDCA
+ F59B1C2BB8D588CA754D1257BFF76B53984DF4937093AAEF79009D32A29A4C16
+ FB610C7D6713482C48D7F9E8410C0F00AD6E67021056B6035534E79F05D14EF2
+ 4E87E9E4707985926D1310CA26FA89778C50A25FC774CACF262C7F3827932F70
+ 99418EF7F013BA1F3CFEF4F914E6EDCD8381A20EC1C09F9622B54776A1D75B15
+ 861A3964CF96AB5E0CE613D02E2490A727226901913A1C7519F31E5AF7956834
+ 0530949DA24E348C4E31DC8EA2686E0B9D950317057AD524F8E43536B4BE36BF
+ 76D96BFA526FD1F0CFA508F7C1D40046EC9FA78794A295425A0DCCCD59510A3C
+ EAD2F1F9FFD74E911B99D067FDA3F12ADEE8B9F70DB69D63E89C2155FDFF66D2
+ E8D87194215B44D34B23CACFFE61F5FF213470090661403C863AD0796AB6F272
+ E703561F7E94E0F538DEF9F7A79D7D2979DEA51C18A45D4A5537C5640E5EBA58
+ F115C4DC10FCE02C270C986B8841C02CFBA5CE179FB41444054FCE5C7027104D
+ 0C0B3E87A54F0B59E1BB072BDD61C94AF1A906D7D853BBC71086A61A364314D5
+ F95215B4047D4B0C9E7474FC78C0695579D933FE26A4EE9E7332AC1FC54250BE
+ 43A453928600FEDD601BE9709816F3CDE77749F5ACAEA3E557C9D0D399FA22FE
+ 1671AFFC8FBC83CD25EED4D35BC2FD6C28433FFFFF2B087D4FD56FAFB55BFEDC
+ 7694DA72C11C9772BABEC9B3049471F1A96FF76ECF30B5B96C2BF2E2F95A38A9
+ 5C3B1876AB22F04B0F87EFD430D275933F71E12E2D922F4B122EDDD4BE92F3C2
+ 7DE4B0BD6B9FDDB24317102B2F512D17D2CDFCB372DE75E0209524355112C363
+ F13CA2F24713C7AA9F8D9039A8CAB02CA19DDB17C55E665423B92B3B948B3244
+ CD991D463334D364DEAC7717256F5C7FC724BEA69D17AEE7894E0134F8C62F12
+ 47C8EB847E36F0D8FF3676EBFADFBA921CADB81935A51695A5E9D7D322B74C34
+ C9AF65B062C24466AC274211038AB250E56FA573BAC2C996D7B403DB232F97FB
+ 71256EF7979928F193B84E7B4D30D53BF0AAAF037BBFD3BB24D6672FBAD84CA2
+ 1F590CDA81314778E068B4484CCEAD6D2DDD2D5C1757E9CB496AC021E852C962
+ 847B646BDB3EC7A957CCBFEE8598F61ED903AD191FF4E9B35E13F3CFE47281DD
+ A3EE0037E3C0C40E4F7F3B8A310ED033513097071110D75CA70F787B92D4EE15
+ A670DE31883D9A74275AD4EAD42DEA456D656ECE50E35C0AD3BFCBBD91CC564E
+ 4A87567CEBAF2CC22536D61CFD598AC62C9CD9FCC384D3306A4F55E4184B1FD9
+ FFBAFB41060C3A7ECAEF2DBFD3FE891C3FA3F7605F0D9AB859FDED8EC544C9D2
+ DE55C7CCCE9F11B9038413D1CA77EDD5BC2F2F0376267BB18D8A4DACD29E3A60
+ 02F473465C63FC13483F61C22A5AB75A936A0756A210508227D20879A21E714D
+ 36EAECB57942858C5CCC703F9CA713B84A9E994312757FF739DD4685B7B4C8DF
+ 881EF093C0D7EB3B20D2192EABF9DD2D4381DDDE7FD80E9545A8377FF14E7277
+ D4C2B3127E15F58F59318BEB923588C25F7449057A2FF63E01632A256E1D6F9E
+ 370E02C64944E7A32C75F70E08CD5C64E504F148A37B2987F1212B8F5D63565B
+ 65DCED5A6963C511AE6DE68E617DB8A4E15ABB86B5497B631632722E100EB49C
+ C13FE7BF1BD16108CDF98E87AC117E7D794C93CB7FE8A2F073A1DBC995465EB5
+ 39DEDF2E537F6A47AEB9F986A24C5A79754714817A121CC269C337DCB7C36B38
+ 7286EFD2BA015E5CA3C1745C807B6247C0A185957BF1E73B97FDDBD52826370B
+ 59498A2F4EBA662AA627908EEC3F49D12957EEDB41E7A4E10126285524B906C2
+ 9219408A175A16DB04DAD138495E038DF36BBCAFA9311CF1F2EB320934B96068
+ 132ACB700D2ABF9570AE866BDCC1A6AA61F253EA61BA4895D8A20667C2AEA85A
+ 70B10BEF5F06FA6BB56E85319699DD26913B6CBF25D08D658DC7800451AF85BD
+ 6BCF1EA1BBC179D8D376188980A372B4F7CC59277A1C0EEC1FFFE5BDAA9BB622
+ 9423E1A92C429A383B4A28F5182209A159B39B064FB5A54D98E77E14DDE88F29
+ 1F866189EAE45AB8ED960A4D248181E5DE06F7930C337940A0A8D9FB64075AD3
+ 55D5073EBAB53918FEAB65EA8025071215E329CAD546B6092B0F3F4F517BBCE9
+ 0592403A768DB6266377513894A671B2EF26B6530B2AD1DBE268BC6C111B1260
+ A0335DE411B2CF202E50902E258B4CCB37431DFD8F544F1ECF29BE9614E38D52
+ FD844AC471F931C03C528CE9C9957F20090E51ECDE7739DAF02BA6C2F4CC9B23
+ 0D117084FEF7DA806A365A503F7D046CF00B506140A1BAD1624AB506835716D4
+ 1D250EFF06FF8E9A41672182500FE31EFC0D0166F86878C81494E418D20F7731
+ 372FEABF14C038FFD2D56871B82E8A3E98FD745B9FCD1F41F80146E5F3A4188B
+ 8DE431AF5BAE213193678FAFE82DF66835E70DC7DF5918EF944A3F8A6CE5634E
+ D937C3DB7F0327BEC2E014CCF6C199F68313000E867F60996BE93762CBEEB749
+ 4F56E4ABE9C4735E069A414D237EF88593D4279DD000AACE54C626A0BA3035D7
+ 89A2CAF097A5CC22C23C9A7BA986D5005F2FA0436E9ED1D3B9EBD27A4E443C4A
+ 45D2E209573CF9F0152F19E98892024264A4F2991E2C1A2038D3F2B286A8E475
+ 3921BBD967E5D1F8523BEF8622347A1353885C24B5AE6A804113ECA61AE9C817
+ D57206DE39761AF648047CD105EAEB9165ADE54A9F0742F86C4D1272ABAE02D1
+ 49511472EDD7912C738F41C7F78E897291F3C188C1B098EA19E598B638AC4CAD
+ 555ABF7F4ECA6FF5A5E7E196DECE12EF5C8A348643C14F780C7BE793026E5725
+ A9A6C14C72190BE2BA0ACA20C079B77771F9A44FD87E79096FCECD6223FB5170
+ 8B4C226783A4996984F9F239B05C29E2DA9DE58C28963579DA2AC7950B8DC330
+ 60440A6CF4C52145644F5B0BEDC7F989299E4676106B5D13768052ABEE63778C
+ 59AA2C3E0B312CB5AAC46C4678668D3E344A2E52FD2E2055CD33E6404AB08663
+ 35AC9031E8C5F036AD471423C7A7DCEE44EBAD7AD3A6CEC9C7B3D3588F1D92DF
+ 9ED078639F0C86FD6B3172AAC0D1D47111E14A916B79B1C65C6223C94973BB5F
+ EB99F01EA8DCB626D2D18433D6E95C04BEE4AEF50BE423E6A760F0AF3E0F999B
+ 4056CBB1D0175093154C5F45094280E242F852561F7CA22026CBDCDCFB35B5F2
+ 06DCE9A4F454635430C9BB7D25482275B11278DEBE9A45C02F9FF4C9EC00587F
+ 466F0287E62E076612988F4AFA3910D083FA5FA0878F12C0ED074E48EAF872D2
+ 37A39E61835ED5DA1920A001F389233DFFE0F3147577F95804A7A0C1D9B35832
+ 1B8D04271C87191A2C3664992051E13564C6F5CD7354847C17EBB328E08AF917
+ F4A3863C425EB91DBCA0AE12D361F4634B7E88612428CD362C5C97B5C377372A
+ 6EDF9B24BB60CF7E2360B2B68442B8EDC637E675E06C159E09139E87CC968DA8
+ 2EE075758659A00F94CC21C7EA4CD979581EA724EABE795153A4D28D7A3B3BC7
+ B326B865C6BB6FAA210599F1AF49CB7B801CE3DAA1B06CC758EC932EB9C2378F
+ 6C00BB8D99E4627C6359C9317CC1A8ACBC15B4610D61D75BDD0B764FF9F37AEA
+ 4733B8BFC6BBD9C24F28FB525B133FCA64EC8F068405A3B3659669CFEBF56067
+ 46243354C643DABF278CD9B4BA23449F33518CDD6410110BEAC8621EFADE0BAC
+ 7302187A88E90B22AA28EB270E0805E19CE59075AAC9189E359259C5663E5C81
+ E7C38D40CF2502BFFB4D6D8AF3B06BB4A1D270B1DBC6F0C06C4945109EA6E17F
+ CCD9FE275D18E12E648F48AF92417EE9C1C610DF9E206B81E573BBAA0988D9EF
+ FB2D1FD66B3175F31D99C6693B8AF6799B25E37EE7A785BE53869DD36C96A0DF
+ FF6E48857C406697BBF62B7FD19F26AA166F3C661D80C8B3D55782B7E4E3F7DB
+ 7A4B675413A63250BFF5F0FB1383570460B0BF5E4604E147D5C727861B4A62EC
+ C4EA069AA4F1A0218BD44BEE81FBED6FCFC4BCF223F7EA8DA16584EF120E6EE5
+ B03908799B4F285BB6D74E0F295D74A6A8880BD1E8963F41031BFA291B7E6B83
+ 873EA0C356D60EA6D34D036218631CC81F2EC17B0C42D84C68CDAC3C2E5C3259
+ 47628BBFC36DC611D58380DBE438DD949AEFA51AD7BA686B4D5BA06FB94B9A47
+ 5C3F3BBD4D22289A90A778000582F41D2E7B74BB22F1C23E23B1BA6332C68E15
+ 1A639ACA983D6ED273128322B0131E2211683DAD6AF1B778CE6F9D289A4A20D4
+ AD99A43C6B430FD3A15E04D1299F5EBF874CE8528890C070585BBDE64E8E01D0
+ 36AB6098469E49F2310B5A628809A208F8D34500BCAE6687E21CA760B2BD383F
+ 27C5F7AD17F4602C02DB2C78BAC5A32705A5888EAB1FD38B35CA236702A8D71D
+ 842C63FCD304C384E4DD1B9408F09D87794E4314431BAA5711F92D31BEF49510
+ A39FBD0E857484912244E99C0894618A9B5B093E53167836ABF9D7987FEEC017
+ 639FCF23FB7C1DE302CE77DCB002DA733292E01F0AD2F48148D14631AC8158DB
+ 00AA1FD6C6A91A30B5FB8800415F8124E049C63BEF4E0FB5F35FA3530857D342
+ 327CA4B01EFDA9F9503194B9D3683B34EBEEE7E9D55440A7784651967D955589
+ 690F89D5905BC89BB641B31705F7C75E15F5427D5CACE41DB514FB2512063653
+ E173393332C43175D607AA13491B977CEED3048B45026FA793F543EC8AF53DDD
+ 1B94D4753AA2E64F0E7A2D7EB883336A252DAD72A4F2489D68894E169FFA29C1
+ 46A7B26063D0784599054F980A501BA69BFDE1C8E9F326B0BA0F2981F668EC91
+ 3EB6FF180A72A13828625C81688A6A2044963C4C85EF281D2466C441B62C6FA4
+ DEDC270BB364D3CCC8533FC917EC3330E75E0C5B8ACD357FEB0D7A56BD5F9092
+ 5597A5E5E8A44928A00AFD6C99F9CA1E3DE5C6E7DAD1B5BA4CEB03055194E270
+ 5068CCE65C1383E7D5DAF477261A126EF9E8D09CD3245572D39C00F5A7AE5AD8
+ 6143AD3C260D23CB9E2CF3FDF65C435845F7AB66F4D2724B36892B0DBE2CE87E
+ 3D4ACE0FEABB3720544E27FB8DE0E0BC6E84DB7505444934E3184CEB1BEC9E7E
+ 52C50D31094A60CE744FC80C4DAE0E021C1AE02015D453335A23520F12CC8335
+ 9BE08C21D5CB4A142520A11AE694533673B05ACA1E3993E67F4F0947BB78E3B5
+ 7BB71BFA0A8932EDFEBE7F8DE6102C7FBC417D6F11D795C5AD1848221C7427B3
+ 4A897152979EEA7D3BD33A9AE655574EB757012D4632B437128E728216E7CF1A
+ 5613F4DD14D1744918473425BE6D770A32DA247A7ABC69132EE113867E98FF82
+ F2C65BDBD7529D37B5BFB5FE3F1EF37FB6D3573BD58DA51AE67F5981F0589118
+ 6443B7BD8C1C0B10552A39EB405AC6005B6869538AD8F751AF7040920E60804C
+ EF8AE2385DB58CA854858E9CB3BFE5227D9F62F37BC61F16F2207F4C8B3C73AC
+ 34145E3F68A5787CE3552D765E5F22B4C31C4DF62F30C585BBBB96C232C20E14
+ B4321BC779BBB5372326D7526C8DC163B2B821DB78BDA485F47B9F4585339731
+ 315630505A4CA425F7195E1316CC1FCD57658B46E142A05D2882343F2721A69D
+ 6792D3B1BAEF15566FE991B880A4926F2872AFD9BC920CCE430471B37D0D279A
+ 9FDE26DC859DC3D2F7367E96619BBC2825B001B46F648180E13E14B766C5F5BE
+ 8EEAF2FE1B34A55A9FBD09EF2C325B3CC28A177936DCF4FBD206C60260E45352
+ 6CE535AE182E8EC159514D849337003A1CF78EAD77B0E38DD03C
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ %%EndFont 
+ TeXDict begin 40258431 52099146 1000 1200 1200 (thesis.dvi)
+ @start /Fa 129[95 6[95 1[95 95 95 95 1[95 95 95 95 95
+ 2[95 95 95 95 95 95 95 95 95 38[95 10[95 95 95 45[{}24
+ 181.818 /CMTT10 rf /Fb 133[74 88 2[84 98 60 74 77 84
+ 93 93 102 149 46 84 1[56 93 84 56 84 93 84 84 93 9[182
+ 1[135 130 102 133 1[123 139 135 163 114 1[95 70 135 141
+ 1[123 137 130 1[135 6[56 93 93 93 93 93 93 93 93 93 93
+ 1[56 65 56 2[74 74 56 39[{}58 181.818 /CMTI10 rf /Fc
+ 205[83 50[{}1 99.6264 /CMSY6 rf /Fd 135[71 2[71 71 71
+ 71 2[71 71 71 71 2[71 71 1[71 71 71 2[71 1[71 11[71 2[71
+ 1[71 19[71 71 71 71 71 71 71 71 71 71 71 3[71 2[71 71
+ 4[71 35[{}34 132.835 /CMTT8 rf /Fe 137[62 73 48 58 9[44
+ 21[75 2[78 3[84 16[38 59[{}9 99.6264 /CMMI6 rf /Ff 134[93
+ 93 1[93 98 69 70 73 93 98 88 98 147 49 93 1[49 98 88
+ 54 81 98 79 98 86 3[49 1[49 11[133 5[67 1[139 2[135 128
+ 126 133 3[138 2[49 88 88 88 88 88 88 88 88 88 88 1[49
+ 1[49 1[88 4[147 2[92 20[98 98 12[{}51 149.44 /CMBX9 rf
+ /Fg 152[71 71 45[78 5[94 46[71 2[110{}6 132.835 /CMSY8
+ rf /Fh 137[69 82 2[64 12[65 73 61 12[82 2[86 2[89 17[110
+ 1[110 39 43[57 15[{}13 132.835 /CMMI8 rf /Fi 135[86 1[86
+ 90 63 64 67 86 90 81 90 136 45 86 1[45 90 81 50 75 90
+ 72 90 79 97[{}22 132.835 /CMBX8 rf /Fj 133[93 110 110
+ 151 110 116 81 82 86 110 116 105 116 174 58 110 64 58
+ 116 105 64 96 116 93 116 102 10[158 1[145 116 157 1[143
+ 2[198 3[79 1[164 2[160 151 1[158 7[105 105 105 105 105
+ 105 105 105 105 105 1[58 70 58 2[81 81 27[116 12[{}53
+ 181.818 /CMBX10 rf /Fk 134[118 1[162 118 125 87 88 92
+ 1[125 112 125 187 62 118 1[62 125 112 68 102 125 100
+ 125 109 12[156 125 167 1[153 2[213 135 2[83 175 2[147
+ 172 162 159 169 10[112 112 112 112 112 112 2[62 75 45[{}43
+ 199.253 /CMBX12 rf /Fl 202[61 61 61 61 61 7[48 48 40[{}7
+ 99.6264 /CMR6 rf /Fm 135[87 110 75 88 55 72 69 1[77 74
+ 93 135 46 80 63 53 88 73 75 71 80 66 66 81 10[90 2[94
+ 116 1[98 117 123 148 105 2[67 1[120 1[113 127 110 116
+ 115 2[119 1[119 1[43 27[91 8[90 6[68 14[{}44 149.44 /CMMI9
+ rf /Fn 149[43 2[77 77 9[102 102 31[77 102 1[85 1[0 2[102
+ 102 46[77 2[119{}13 149.44 /CMSY9 rf /Fo 134[74 74 1[74
+ 78 55 56 55 1[78 71 78 118 39 74 1[39 78 71 43 63 78
+ 63 78 71 3[39 1[39 4[106 106 102 78 104 1[96 110 1[129
+ 88 110 1[51 106 111 92 96 1[102 100 106 3[110 1[39 39
+ 71 71 71 71 71 71 71 71 71 71 1[39 1[39 110 1[55 55 2[118
+ 1[118 71 34[{}63 132.835 /CMR8 rf /Fp 139[107 83 109
+ 1[101 116 112 136 93 2[55 112 2[101 114 2[112 97[{}13
+ 181.818 /CMCSC10 rf /Fq 134[89 104 1[88 104 66 85 82
+ 3[109 160 54 2[63 2[89 85 95 79 1[96 12[106 111 138 1[117
+ 139 146 176 124 2[80 151 3[151 1[138 136 2[141 91 141
+ 29[108 8[106 6[81 14[{}35 181.818 /CMMI10 rf /Fr 149[51
+ 2[91 91 44[101 5[121 121 182 33[91 11[91 141 1[141{}11
+ 181.818 /CMSY10 rf /Fs 132[77 68 81 81 111 81 85 60 61
+ 60 81 85 77 85 128 43 81 47 43 85 77 47 68 85 68 85 77
+ 3[43 1[43 4[115 115 111 85 113 1[105 119 115 141 96 119
+ 1[55 115 121 1[105 117 111 109 115 2[73 119 43 43 43
+ 77 77 77 77 77 77 77 77 77 77 77 43 51 43 119 77 60 60
+ 43 119 128 1[128 1[43 18[128 85 85 90 11[{}80 149.44
+ /CMR9 rf /Ft 133[120 1[142 194 142 149 105 106 110 1[149
+ 134 149 224 75 142 1[75 149 134 82 123 149 120 149 131
+ 10[203 207 187 149 201 1[184 202 210 255 162 2[100 1[211
+ 1[177 206 194 1[203 9[134 134 134 134 134 134 134 2[75
+ 46[{}47 239.103 /CMBX12 rf /Fu 134[96 96 131 96 101 71
+ 72 71 1[101 91 101 152 51 96 1[51 101 91 56 81 101 81
+ 101 91 11[136 1[101 134 1[124 2[167 114 2[66 136 143
+ 1[124 139 131 129 136 19[61 45[{}38 181.818 /CMSL10 rf
+ /Fv 139[151 1[158 1[215 7[215 2[177 3[188 29[280 11[194
+ 194 194 194 194 194 194 49[{}14 344.375 /CMBX12 rf /Fw
+ 135[245 336 245 258 181 183 190 1[258 232 258 387 129
+ 245 1[129 258 232 142 212 258 207 258 226 9[480 2[323
+ 258 347 1[317 2[441 279 2[173 2[292 305 1[336 330 351
+ 65[{}35 413.118 /CMBX12 rf /Fx 132[91 81 96 96 131 96
+ 101 71 72 71 96 101 91 101 152 51 96 56 51 101 91 56
+ 81 101 81 101 91 3[51 91 51 111 136 1[187 136 136 131
+ 101 134 1[124 141 136 167 114 141 93 66 136 143 119 124
+ 139 131 129 136 3[141 2[51 91 91 91 91 91 91 91 91 91
+ 91 91 51 61 51 141 91 71 71 51 141 152 1[152 91 14[91
+ 3[152 152 101 101 106 11[{}85 181.818 /CMR10 rf /Fy 166[146
+ 146 200 1[146 141 108 144 1[133 152 146 179 122 152 1[70
+ 146 153 127 133 149 141 138 146 18[54 46[{}23 199.253
+ /CMR12 rf end
+ %%EndProlog
+ %%BeginSetup
+ %%Feature: *Resolution 1200dpi
+ TeXDict begin
+ %%BeginPaperSize: Letter
+ letter
+ %%EndPaperSize
+  end
+ %%EndSetup
+ %%Page: 1 1
+ TeXDict begin 1 0 bop 90 1636 a Fy(AN)65 b(IMPLEMENT)-16
+ b(A)g(TION)65 b(OF)g(SWING)h(MODULO)f(SCHEDULING)h(WITH)g(EXTENSIONS)
+ 2921 1862 y(F)-5 b(OR)64 b(SUPERBLOCKS)3767 3741 y Fx(BY)2894
+ 4166 y Fy(T)-16 b(ANY)g(A)65 b(M.)g(LA)-16 b(TTNER)2553
+ 4591 y Fx(B.S.,)59 b(Univ)-5 b(ersit)g(y)59 b(of)h(P)-5
+ b(ortland,)59 b(2000)3570 6757 y(THESIS)1851 7183 y(Submitted)g(in)h
+ (partial)f(ful\014llmen)-5 b(t)58 b(of)i(the)g(requiremen)-5
+ b(ts)1666 7408 y(for)60 b(the)h(degree)f(of)g(Master)f(of)i(Science)e
+ (in)h(Computer)g(Science)2684 7634 y(in)h(the)f(Graduate)g(College)f
+ (of)h(the)1934 7860 y(Univ)-5 b(ersit)g(y)59 b(of)h(Illinois)e(at)i
+ (Urbana-Champaign,)g(2005)3283 9859 y(Urbana,)h(Illinois)p
+ eop end
+ %%Page: 3 2
+ TeXDict begin 3 1 bop 0 1511 a Fw(Abstract)0 2541 y Fx(This)74
+ b(thesis)e(details)h(the)h(implemen)-5 b(tation)70 b(of)k(Swing)g(Mo)5
+ b(dulo)73 b(Sc)-5 b(heduling,)76 b(a)e(Soft)-5 b(w)g(are)73
+ b(Pip)5 b(elining)72 b(tec)-5 b(h-)0 2906 y(nique,)71
+ b(that)f(is)f(b)5 b(oth)70 b(e\013ectiv)-5 b(e)69 b(and)h(e\016cien)-5
+ b(t)68 b(in)i(terms)f(of)h(compile)e(time)h(and)h(generated)f(co)5
+ b(de.)109 b(Soft)-5 b(w)g(are)0 3271 y(Pip)5 b(elining)64
+ b(aims)h(to)g(exp)5 b(ose)66 b(Instruction)e(Lev)-5 b(el)65
+ b(P)-5 b(arallelism)63 b(in)j(lo)5 b(ops)65 b(whic)-5
+ b(h)66 b(tend)g(to)g(help)f(scien)-5 b(ti\014c)64 b(and)0
+ 3637 y(graphical)59 b(applications.)282 4002 y(Mo)5 b(dulo)53
+ b(Sc)-5 b(heduling)52 b(is)g(a)i(category)e(of)h(algorithms)f(that)g
+ (attempt)g(to)h(o)-5 b(v)g(erlap)53 b(iterations)e(of)i(single)f(basic)
+ 0 4367 y(blo)5 b(c)-5 b(k)57 b(lo)5 b(ops)57 b(and)h(sc)-5
+ b(hedule)56 b(instructions)g(based)h(up)5 b(on)58 b(a)g(priorit)-5
+ b(y)57 b(\(deriv)-5 b(ed)57 b(from)g(a)g(set)g(of)h(heuristics\).)77
+ b(The)0 4733 y(approac)-5 b(h)76 b(used)g(b)-5 b(y)76
+ b(Swing)g(Mo)5 b(dulo)76 b(Sc)-5 b(heduling)75 b(is)g(designed)g(to)h
+ (ac)-5 b(hiev)g(e)75 b(a)i(highly)e(optimized)f(sc)-5
+ b(hedule,)0 5098 y(k)g(eeping)60 b(register)f(pressure)h(lo)-5
+ b(w,)60 b(and)g(do)5 b(es)61 b(b)5 b(oth)60 b(in)g(a)h(reasonable)e
+ (amoun)-5 b(t)60 b(of)g(compile)e(time.)282 5464 y(One)78
+ b(dra)-5 b(wbac)g(k)77 b(of)f(Swing)h(Mo)5 b(dulo)76
+ b(Sc)-5 b(heduling,)79 b(\(and)e(all)f(Mo)5 b(dulo)76
+ b(Sc)-5 b(heduling)76 b(algorithms\))e(is)j(that)0 5829
+ y(they)j(are)g(missing)e(opp)5 b(ortunities)78 b(for)i(further)g
+ (Instruction)e(Lev)-5 b(el)79 b(P)-5 b(arallelism)77
+ b(b)-5 b(y)80 b(only)f(handling)h(single)0 6194 y(basic)g(blo)5
+ b(c)-5 b(k)80 b(lo)5 b(ops.)141 b(This)81 b(thesis)e(details)g
+ (extensions)g(to)i(the)g(Swing)f(Mo)5 b(dulo)81 b(Sc)-5
+ b(heduling)79 b(algorithm)g(to)0 6560 y(handle)j(m)-5
+ b(ultiple)80 b(basic)h(blo)5 b(c)-5 b(k)82 b(lo)5 b(ops)81
+ b(in)h(the)g(form)g(of)g(a)g(sup)5 b(erblo)g(c)-5 b(k.)145
+ b(A)83 b(sup)5 b(erblo)g(c)-5 b(k)81 b(is)h(group)g(of)g(basic)0
+ 6925 y(blo)5 b(c)-5 b(ks)53 b(that)g(ha)-5 b(v)g(e)53
+ b(a)h(single)e(en)-5 b(try)53 b(and)h(m)-5 b(ultiple)51
+ b(exits.)77 b(Extending)52 b(Swing)i(Mo)5 b(dulo)53 b(Sc)-5
+ b(heduling)52 b(to)h(supp)5 b(ort)0 7290 y(these)58 b(t)-5
+ b(yp)5 b(es)58 b(of)g(lo)5 b(ops)57 b(increases)g(the)i(n)-5
+ b(um)g(b)5 b(er)58 b(of)g(lo)5 b(ops)58 b(Swing)g(Mo)5
+ b(dulo)58 b(Sc)-5 b(heduling)57 b(can)h(b)5 b(e)59 b(applied)e(to.)79
+ b(In)0 7656 y(addition,)e(it)e(allo)-5 b(ws)74 b(Mo)5
+ b(dulo)74 b(Sc)-5 b(heduling)74 b(to)h(b)5 b(e)75 b(p)5
+ b(erformed)75 b(on)g(hot)g(paths)g(\(also)f(single)f(en)-5
+ b(try)-15 b(,)78 b(m)-5 b(ultiple)0 8021 y(exit\),)59
+ b(found)h(with)g(pro\014le)g(information)e(to)j(b)5 b(e)60
+ b(optimized)f(later)g(o\017ine)h(or)g(at)h(run)-5 b(time.)282
+ 8387 y(Our)45 b(implemen)-5 b(tation)40 b(of)k(Swing)f(Mo)5
+ b(dulo)43 b(Sc)-5 b(heduling)43 b(and)h(extensions)e(to)i(the)f
+ (algorithm)f(for)i(sup)5 b(erblo)g(c)-5 b(k)0 8752 y(lo)5
+ b(ops)86 b(w)-5 b(ere)87 b(ev)-10 b(aluated)85 b(and)i(found)g(to)f(b)5
+ b(e)87 b(b)5 b(oth)87 b(e\013ectiv)-5 b(e)85 b(and)i(e\016cien)-5
+ b(t.)157 b(F)-15 b(or)87 b(the)f(original)f(algorithm,)0
+ 9117 y(b)5 b(enc)-5 b(hmarks)58 b(w)-5 b(ere)60 b(transformed)e(to)h
+ (ha)-5 b(v)g(e)59 b(p)5 b(erformance)58 b(gains)g(of)h(10-33\045,)f
+ (while)g(the)h(extended)g(algorithm)0 9483 y(increased)g(b)5
+ b(enc)-5 b(hmark)60 b(p)5 b(erformance)60 b(from)f(7-22\045.)3824
+ 11136 y(iii)p eop end
+ %%Page: 4 3
+ TeXDict begin 4 2 bop 0 1511 a Fw(Ac)-13 b(kno)g(wledgmen)g(ts)0
+ 2541 y Fx(The)80 b(implemen)-5 b(tation)77 b(and)k(writing)e(of)h(this)
+ f(thesis)g(has)h(b)5 b(een)80 b(c)-5 b(hallenging,)83
+ b(stressful,)f(y)-5 b(et)80 b(ful\014lling)e(and)0 2906
+ y(rew)-5 b(arding.)84 b(While)61 b(I)h(feel)f(a)h(sense)f(of)g(pride)h
+ (in)f(what)h(I)g(ha)-5 b(v)g(e)62 b(accomplished,)d(I)j(w)-5
+ b(ould)62 b(not)f(ha)-5 b(v)g(e)62 b(completed)0 3271
+ y(this)k(without)g(the)h(immense)e(lo)-5 b(v)g(e)66 b(and)i(supp)5
+ b(ort)66 b(from)h(m)-5 b(y)66 b(h)-5 b(usband)67 b(Chris.)100
+ b(I)67 b(ha)-5 b(v)g(e)66 b(w)-5 b(atc)g(hed)67 b(him)f(ac)-5
+ b(hiev)g(e)0 3637 y(inspirational)69 b(success)h(in)i(his)e(o)-5
+ b(wn)72 b(educational)e(pursuits)h(and)g(learned)g(a)h(great)f(deal)g
+ (from)g(him.)113 b(He)71 b(has)0 4002 y(alw)-5 b(a)g(ys)61
+ b(sto)5 b(o)g(d)60 b(b)-5 b(y)62 b(me)e(despite)g(m)-5
+ b(y)61 b(frequen)-5 b(t)61 b(stress-induced)e(break)i(do)-5
+ b(wns.)83 b(I)61 b(can)g(not)g(thank)g(him)f(enough)0
+ 4367 y(for)g(his)g(patience,)f(understanding,)g(encouragemen)-5
+ b(t,)58 b(and)j(lo)-5 b(v)g(e.)282 4733 y(I)52 b(w)-5
+ b(ould)52 b(also)g(lik)-5 b(e)51 b(to)h(thank)g(m)-5
+ b(y)52 b(paren)-5 b(ts,)53 b(Greg)f(and)g(Ursula)g(Brethour.)77
+ b(Y)-15 b(ou)53 b(b)5 b(oth)52 b(ha)-5 b(v)g(e)52 b(supp)5
+ b(orted)52 b(m)-5 b(y)0 5098 y(seemingly)67 b(crazy)j(decision)e(to)h
+ (attempt)f(graduate)h(sc)-5 b(ho)5 b(ol.)106 b(Thank)70
+ b(y)-5 b(ou)70 b(for)f(y)-5 b(our)70 b(lo)-5 b(v)g(e)68
+ b(and)i(supp)5 b(ort,)71 b(and)0 5464 y(for)60 b(bringing)g(me)g(up)h
+ (with)f(the)g(determination)e(to)i(succeed)g(no)g(matter)g(what)g(the)g
+ (adv)-5 b(ersit)g(y)-15 b(.)282 5829 y(I)63 b(am)f(also)g(v)-5
+ b(ery)63 b(grateful)f(to)g(Jim)h(F)-15 b(erguson,)62
+ b(of)g(NCSA,)i(for)f(allo)-5 b(wing)61 b(me)h(to)h(reduce)g(m)-5
+ b(y)62 b(app)5 b(oin)-5 b(tmen)g(t)0 6194 y(and)72 b(attend)f(graduate)
+ g(sc)-5 b(ho)5 b(ol.)113 b(Without)71 b(y)-5 b(our)72
+ b(letter)f(of)g(recommendation,)h(\014nancial)f(supp)5
+ b(ort,)74 b(and)d(un-)0 6560 y(derstanding,)80 b(this)d(w)-5
+ b(ould)77 b(not)h(ha)-5 b(v)g(e)77 b(b)5 b(een)77 b(p)5
+ b(ossible.)130 b(I)78 b(learned)f(a)g(lot)g(from)g(y)-5
+ b(ou)77 b(and)h(m)-5 b(y)77 b(fello)-5 b(w)76 b(D)-5
+ b(AST)0 6925 y(co)g(w)g(ork)g(ers,)60 b(and)g(I)h(am)f(extremely)f
+ (grateful)g(for)h(ev)-5 b(erything.)282 7290 y(Sp)5 b(ecial)74
+ b(thanks)g(to)g(m)-5 b(y)74 b(advisor,)j(Vikram)d(Adv)-5
+ b(e,)78 b(who)d(help)5 b(ed)74 b(me)g(pursue)g(m)-5 b(y)74
+ b(dreams)g(of)g(writing)g(a)0 7656 y(thesis.)79 b(Thank)61
+ b(y)-5 b(ou)60 b(for)g(y)-5 b(our)61 b(guidance,)e(kno)-5
+ b(wledge,)59 b(and)i(supp)5 b(ort.)282 8021 y(Lastly)-15
+ b(,)76 b(I)e(o)-5 b(w)g(e)74 b(a)g(lot)f(to)h(the)g(friends)f(I)h(ha)-5
+ b(v)g(e)74 b(made)f(during)h(m)-5 b(y)74 b(y)-5 b(ears)74
+ b(at)g(UIUC.)g(Thank)g(y)-5 b(ou)75 b(for)e(the)0 8387
+ y(laugh)-5 b(ter,)59 b(fun,)h(memories,)e(and)i(for)h(k)-5
+ b(eeping)59 b(me)h(sane.)3827 11136 y(iv)p eop end
+ %%Page: 5 4
+ TeXDict begin 5 3 bop 0 1511 a Fw(T)-39 b(able)156 b(of)f(Con)-13
+ b(ten)g(ts)0 2583 y Fx(List)59 b(of)h(Figures)158 b(.)91
+ b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)153 b(vii)0 2990 y(List)59
+ b(of)h(T)-15 b(ables)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)103
+ b(viii)0 3398 y(Chapter)61 b(1)181 b(In)-5 b(tro)5 b(duction)48
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)259 b(1)273 3624 y(1.1)185 b(Mo)5
+ b(dulo)60 b(Sc)-5 b(heduling)95 b(.)90 b(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259 b(2)273
+ 3850 y(1.2)185 b(Researc)-5 b(h)60 b(Con)-5 b(tributions)59
+ b(of)h(this)f(Thesis)179 b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259
+ b(4)273 4076 y(1.3)185 b(Organization)59 b(of)h(this)g(Thesis)163
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259
+ b(4)0 4483 y(Chapter)61 b(2)181 b(Sc)-5 b(heduling)59
+ b(Bac)-5 b(kground)173 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)259 b(5)0 4891 y(Chapter)61 b(3)181 b(Previous)60
+ b(W)-15 b(ork)151 b(.)90 b(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)g(.)h(.)259 b(8)273 5117 y(3.1)185
+ b(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)59 b(Approac)-5 b(hes)105
+ b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259
+ b(9)691 5342 y(3.1.1)207 b(Iterativ)-5 b(e)59 b(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling)54 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)168 b(10)691 5568 y(3.1.2)207 b(Slac)-5 b(k)59
+ b(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)170 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)168 b(12)691 5794 y(3.1.3)207 b(In)-5
+ b(tegrated)59 b(Register)g(Sensitiv)-5 b(e)59 b(Iterativ)-5
+ b(e)59 b(Soft)-5 b(w)g(are)59 b(Pip)5 b(elining)80 b(.)90
+ b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(13)691
+ 6020 y(3.1.4)207 b(Hyp)5 b(erno)g(de)61 b(Reduction)e(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling)117 b(.)90 b(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(15)273
+ 6246 y(3.2)185 b(Global)59 b(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)74
+ b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(17)691 6472 y(3.2.1)207 b(Hierarc)-5 b(hical)59 b(Reduction)i(.)90
+ b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(17)691 6697 y(3.2.2)207 b(If-Con)-5 b(v)g(ersion)117
+ b(.)91 b(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)168 b(18)691 6923 y(3.2.3)207 b(Enhanced)60 b(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling)87 b(.)k(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(19)691 7149 y(3.2.4)207 b(Conclusion)164 b(.)90
+ b(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)168 b(20)0 7557 y(Chapter)61 b(4)181 b(Implemen)-5
+ b(ting)58 b(Swing)i(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)99
+ b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)168 b(22)273 7782 y(4.1)185 b(LL)-20
+ b(VM)60 b(Compiler)f(Infrastructure)143 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)168 b(23)691 8008 y(4.1.1)207
+ b(Arc)-5 b(hitecture)59 b(Resource)h(Description)140
+ b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(25)273 8234 y(4.2)185
+ b(Data)60 b(Dep)5 b(endence)60 b(Graph)g(Construction)108
+ b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(27)691 8460
+ y(4.2.1)207 b(Dep)5 b(endence)59 b(Analysis)h(.)91 b(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(28)273 8686
+ y(4.3)185 b(Calculating)59 b(the)h(Minim)-5 b(um)58 b(Initiation)g(In)
+ -5 b(terv)-10 b(al)70 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(32)691
+ 8912 y(4.3.1)207 b(Resource)59 b(I)5 b(I)127 b(.)90 b(.)h(.)f(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(32)691 9137 y(4.3.2)207 b(Recurrence)60 b(I)5 b(I)96
+ b(.)91 b(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)168 b(32)273 9363 y(4.4)185 b(No)5 b(de)61 b(Prop)5
+ b(erties)182 b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(35)273 9589 y(4.5)185
+ b(No)5 b(de)61 b(Ordering)151 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(37)273
+ 9815 y(4.6)185 b(Sc)-5 b(heduling)55 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(39)273 10041 y(4.7)185 b(Lo)5 b(op)60 b(Reconstruction)98
+ b(.)91 b(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)168 b(43)3852 11136 y(v)p eop end
+ %%Page: 6 5
+ TeXDict begin 6 4 bop 0 183 a Fx(Chapter)61 b(5)181 b(Extending)60
+ b(Swing)g(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)59 b(for)h(Sup)5
+ b(erblo)g(c)-5 b(ks)75 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)168 b(48)273 408 y(5.1)185 b(Ov)-5
+ b(erview)167 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(49)273
+ 634 y(5.2)185 b(Changes)60 b(to)g(Dep)5 b(endence)60
+ b(Graph)137 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(50)273 860 y(5.3)185 b(Changes)60 b(to)g(Lo)5 b(op)61
+ b(Reconstruction)137 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(52)273 1086 y(5.4)185 b(Sup)5 b(erblo)g(c)-5 b(k)60
+ b(Lo)5 b(op)60 b(Example)85 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)168 b(54)0 1494 y(Chapter)61 b(6)181
+ b(Results)f(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(64)273 1719
+ y(6.1)185 b(Ultra)60 b(SP)-15 b(AR)-5 b(C)61 b(I)5 b(I)g(Ii)59
+ b(Arc)-5 b(hitecture)150 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)168 b(64)273 1945 y(6.2)185 b(Swing)60 b(Mo)5
+ b(dulo)60 b(Sc)-5 b(heduling)59 b(Results)50 b(.)91 b(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)168 b(66)691 2171 y(6.2.1)207
+ b(Metho)5 b(dology)59 b(and)h(Benc)-5 b(hmarks)172 b(.)90
+ b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(66)691 2397 y(6.2.2)207
+ b(Lo)5 b(op)60 b(Statistics)124 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(67)691 2623
+ y(6.2.3)207 b(Compile)59 b(Time)186 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(70)691 2848
+ y(6.2.4)207 b(Static)59 b(Measuremen)-5 b(ts)81 b(.)91
+ b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(73)691 3074 y(6.2.5)207 b(P)-5 b(erformance)59 b(Results)106
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(76)273 3300 y(6.3)185 b(Sup)5 b(erblo)g(c)-5 b(k)60
+ b(Swing)g(Mo)5 b(dulo)60 b(Sc)-5 b(heduling)59 b(Results)100
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)168 b(79)691 3526 y(6.3.1)207 b(Metho)5
+ b(dology)59 b(and)h(Benc)-5 b(hmarks)172 b(.)90 b(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)168 b(79)691 3752 y(6.3.2)207 b(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Statistics)70 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)168 b(80)691 3978 y(6.3.3)207 b(Compile)59
+ b(Time)186 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)168 b(83)691 4203 y(6.3.4)207 b(Static)59
+ b(Measuremen)-5 b(t)59 b(Results)78 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)168 b(86)691 4429 y(6.3.5)207 b(P)-5 b(erformance)59
+ b(Results)106 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)168 b(88)0 4837 y(Chapter)61 b(7)181 b(Conclusion)174
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)168 b(93)0 5245 y(References)55 b(.)90
+ b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(95)3827
+ 11136 y(vi)p eop end
+ %%Page: 7 6
+ TeXDict begin 7 5 bop 0 1511 a Fw(List)155 b(of)h(Figures)273
+ 2401 y Fx(1.1)185 b(Single)59 b(Iteration)g(of)h(a)h(Lo)5
+ b(op)134 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)259 b(2)273 2627 y(1.2)185 b(P)-5 b(attern)60 b(of)g(Soft)-5
+ b(w)g(are)60 b(Pip)5 b(elined)58 b(Lo)5 b(op)68 b(.)90
+ b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259 b(3)273 2853
+ y(1.3)185 b(Soft)-5 b(w)g(are)60 b(Pip)5 b(elined)58
+ b(Lo)5 b(op)61 b(with)f(Prologue,)f(Kernel,)h(and)g(Epilogue)94
+ b(.)c(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259
+ b(3)273 3245 y(3.1)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(General)e(Mo)
+ 5 b(dulo)60 b(Sc)-5 b(heduling)160 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)259
+ b(9)273 3636 y(4.1)185 b(Simple)59 b(Lo)5 b(op)60 b(Example)146
+ b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)168 b(23)273 3862 y(4.2)185 b(LL)-20 b(VM)60 b(Mac)-5
+ b(hine)59 b(Co)5 b(de)61 b(for)f(a)g(Simple)f(Lo)5 b(op)119
+ b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(24)273 4088 y(4.3)185
+ b(LL)-20 b(VM)60 b(Instructions)e(and)j(Corresp)5 b(onding)60
+ b(Mac)-5 b(hine)59 b(Instructions)184 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)168 b(26)273 4314 y(4.4)185 b(Dep)5
+ b(endence)60 b(Graph)g(After)g(Dep)5 b(endence)60 b(Analysis)142
+ b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)168 b(29)273 4540 y(4.5)185 b(Pseudo)60
+ b(Co)5 b(de)60 b(for)h(Dep)5 b(endence)59 b(Analyzer)75
+ b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(30)273 4765
+ y(4.6)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Circuit)e(Finding)h
+ (Algorithm)113 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(33)273 4991
+ y(4.7)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(P)-5 b(artial)59
+ b(No)5 b(de)60 b(Ordering)h(Algorithm)122 b(.)91 b(.)f(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(37)273 5217 y(4.8)185 b(Simple)59 b(Lo)5 b(op)60 b(Example)f(P)-5
+ b(artial)59 b(Order)149 b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(38)273 5443 y(4.9)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Final)e(No)5
+ b(de)61 b(Ordering)f(Algorithm)113 b(.)90 b(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(39)273
+ 5669 y(4.10)94 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Sc)-5
+ b(heduling)59 b(Algorithm)66 b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(40)273 5895 y(4.11)94 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Lo)5
+ b(op)60 b(Reconstruction)e(Algorithm)110 b(.)90 b(.)h(.)f(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(44)273 6120 y(4.12)94 b(Mo)5 b(dulo)60 b(Sc)-5 b(heduled)59
+ b(Lo)5 b(op)60 b(for)h(our)f(Example)f(Lo)5 b(op)60 b(\(Prologue\))84
+ b(.)91 b(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(46)273 6346 y(4.13)94 b(Mo)5 b(dulo)60 b(Sc)-5 b(heduled)59
+ b(Lo)5 b(op)60 b(for)h(our)f(Example)f(Lo)5 b(op)60 b(\(Kernel)h(and)f
+ (Epilogue\))144 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(47)273 6738 y(5.1)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Determining)
+ d(V)-15 b(alues)60 b(Liv)-5 b(e)59 b(Outside)h(the)g(T)-15
+ b(race)181 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(52)273 6964 y(5.2)185 b(Pseudo)60 b(Co)5 b(de)60 b(for)h(Lo)5
+ b(op)60 b(Reconstruction)e(Algorithm)i(for)g(Sup)5 b(erblo)g(c)-5
+ b(ks)93 b(.)d(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(53)273 7190 y(5.3)185 b(Simple)59 b(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)60 b(Example)54 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)168 b(55)273 7416 y(5.4)185 b(LL)-20 b(VM)60
+ b(Mac)-5 b(hine)59 b(Co)5 b(de)61 b(for)f(a)g(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)58 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(56)273
+ 7641 y(5.5)185 b(Dep)5 b(endence)60 b(Graph)g(After)g(Dep)5
+ b(endence)60 b(Analysis)142 b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(57)273
+ 7867 y(5.6)185 b(Sup)5 b(erblo)g(c)-5 b(k)60 b(Lo)5 b(op)60
+ b(Example)f(P)-5 b(artial)59 b(Order)88 b(.)i(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(58)273 8093 y(5.7)185 b(Mo)5 b(dulo)60 b(Sc)-5
+ b(heduled)59 b(Lo)5 b(op)60 b(for)h(our)f(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)60 b(\(Prologue\))182 b(.)90 b(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(61)273 8319 y(5.8)185
+ b(Mo)5 b(dulo)60 b(Sc)-5 b(heduled)59 b(Lo)5 b(op)60
+ b(for)h(our)f(Example)f(Lo)5 b(op)60 b(\(Kernel)h(and)f(Epilogue\))144
+ b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(62)273 8545
+ y(5.9)185 b(Mo)5 b(dulo)60 b(Sc)-5 b(heduled)59 b(Lo)5
+ b(op)60 b(for)h(our)f(Example)f(Lo)5 b(op)60 b(\(Side)g(Exit)g(and)g
+ (Side)g(Epilogue\))107 b(.)90 b(.)g(.)h(.)168 b(63)273
+ 8936 y(6.1)185 b(Compile)59 b(Times)h(for)g(the)g(Phases)f(of)i(SMS)141
+ b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(72)273 9162
+ y(6.2)185 b(Theoretical)59 b(I)5 b(I)60 b(to)g(Ac)-5
+ b(hiev)g(ed)60 b(I)5 b(I)60 b(Ratio)98 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)168 b(75)273 9388 y(6.3)185 b(Run)-5 b(time)59
+ b(Ratio)g(Results)76 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)168 b(78)273 9614 y(6.4)185 b(Compile)59
+ b(Times)h(for)g(the)g(Phases)f(of)i(Extended)e(SMS)174
+ b(.)90 b(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)
+ f(.)g(.)h(.)168 b(85)273 9840 y(6.5)185 b(Run)-5 b(time)59
+ b(Ratio)g(Results)76 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)168 b(91)3802 11136 y(vii)p eop
+ end
+ %%Page: 8 7
+ TeXDict begin 8 6 bop 0 1511 a Fw(List)155 b(of)h(T)-39
+ b(ables)273 2401 y Fx(4.1)185 b(No)5 b(de)61 b(Latencies)d(for)i
+ (Simple)f(Lo)5 b(op)61 b(Example)146 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(34)273 2627 y(4.2)185 b(No)5 b(de)61 b(A)-5 b(ttributes)59
+ b(for)h(Simple)f(Lo)5 b(op)60 b(Example)68 b(.)91 b(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(35)273 2853 y(4.3)185 b(Sc)-5 b(hedule)59 b(for)i(a)f(Single)g
+ (Iteration)f(of)h(the)g(Lo)5 b(op)60 b(Example)155 b(.)90
+ b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(41)273 3078 y(4.4)185 b(Kernel)60 b(for)h(Lo)5 b(op)60
+ b(Example)160 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)168 b(42)273 3470 y(5.1)185 b(No)5 b(de)61 b(Latencies)d(for)i
+ (Simple)f(Lo)5 b(op)61 b(Example)146 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f
+ (.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(56)273 3696 y(5.2)185 b(No)5 b(de)61 b(A)-5 b(ttributes)59
+ b(for)h(Simple)f(Lo)5 b(op)60 b(Example)68 b(.)91 b(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(57)273 3922 y(5.3)185 b(Sc)-5 b(hedule)59 b(for)i(a)f(Single)g
+ (Iteration)f(of)h(the)g(Lo)5 b(op)60 b(Example)155 b(.)90
+ b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(59)273 4148 y(5.4)185 b(Kernel)60 b(for)h(Lo)5 b(op)60
+ b(Example)160 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f
+ (.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)168 b(59)273 4540 y(6.1)185 b(Lo)5 b(op)60 b(Statistics)e(for)i
+ (the)g(Benc)-5 b(hmarks)77 b(.)90 b(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)
+ 168 b(68)273 4765 y(6.2)185 b(Compile)59 b(Time)h(Breakdo)-5
+ b(wn)60 b(for)h(Benc)-5 b(hmarks)67 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(71)273 4991 y(6.3)185 b(Static)59 b(Measuremen)-5 b(ts)59
+ b(for)h(the)g(Benc)-5 b(hmarks)174 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(73)273 5217 y(6.4)185 b(P)-5 b(erformance)59 b(Results)g(for)h(the)g
+ (Benc)-5 b(hmarks)58 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h
+ (.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168
+ b(77)273 5443 y(6.5)185 b(Sup)5 b(erblo)g(c)-5 b(k)60
+ b(Lo)5 b(op)60 b(Statistics)e(for)i(the)g(Benc)-5 b(hmarks)127
+ b(.)90 b(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)
+ h(.)f(.)g(.)h(.)168 b(81)273 5669 y(6.6)185 b(Compile)59
+ b(Time)h(Breakdo)-5 b(wn)60 b(for)h(Benc)-5 b(hmarks)67
+ b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)
+ g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(83)273 5895 y(6.7)185
+ b(Static)59 b(Measuremen)-5 b(ts)59 b(for)h(the)g(Benc)-5
+ b(hmarks)174 b(.)91 b(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)h
+ (.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(87)273
+ 6120 y(6.8)185 b(P)-5 b(erformance)59 b(Results)g(for)h(the)g(Benc)-5
+ b(hmarks)58 b(.)90 b(.)h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)h(.)f(.)g(.)
+ h(.)f(.)h(.)f(.)g(.)h(.)f(.)h(.)f(.)g(.)h(.)168 b(89)3776
+ 11136 y(viii)p eop end
+ %%Page: 1 8
+ TeXDict begin 1 7 bop 0 1428 a Fv(Chapter)129 b(1)0 2258
+ y Fw(In)-13 b(tro)13 b(duction)0 3288 y Fx(Mo)5 b(dern)85
+ b(compilers)f(implemen)-5 b(t)83 b(sev)-5 b(eral)85 b(optimizations)d
+ (that)j(extract)g(the)g(parallelism)e(in)i(programs)g(in)0
+ 3653 y(order)79 b(to)f(sp)5 b(eed)79 b(up)f(program)h(execution)e(or)i
+ (to)f(utilize)f(m)-5 b(ultiple)76 b(pro)5 b(cessor)79
+ b(mac)-5 b(hines)77 b(more)h(e\013ectiv)-5 b(ely)-15
+ b(.)0 4019 y(Man)-5 b(y)75 b(of)f(these)g(optimizations)e(are)j
+ (applied)f(to)h(lo)5 b(ops.)123 b(Suc)-5 b(h)75 b(optimizations)c
+ (include)j(lo)5 b(op)75 b(distribution,)0 4384 y(lo)5
+ b(op)74 b(in)-5 b(terc)g(hange,)75 b(sk)-5 b(ewing,)76
+ b(tiling,)g(lo)5 b(op)73 b(rev)-5 b(ersal,)76 b(and)f(lo)5
+ b(op)73 b(bumping)g([36].)120 b(Other)74 b(tec)-5 b(hniques)73
+ b(unroll)0 4749 y(lo)5 b(ops)71 b(to)g(increase)g(the)g(size)f(of)i
+ (the)f(lo)5 b(op)71 b(b)5 b(o)g(dy)72 b(to)f(increase)g(p)5
+ b(oten)-5 b(tial)69 b(for)j(sc)-5 b(heduling.)112 b(This)71
+ b(pro)5 b(duces)71 b(a)0 5115 y(more)60 b(e\016cien)-5
+ b(t)59 b(sc)-5 b(hedule,)59 b(but)h(ignores)g(the)g(parallelism)d
+ (across)j(lo)5 b(op)60 b(iterations)f([31)o(].)282 5480
+ y(Often,)i(these)g(tec)-5 b(hniques)59 b(are)j(not)f(successful)e(due)j
+ (to)f(dep)5 b(endences)60 b(b)5 b(et)-5 b(w)g(een)61
+ b(instructions)e(and)j(across)0 5845 y(iterations)j(of)h(the)g(lo)5
+ b(op.)98 b(A)67 b(more)f(sophisticated)e(approac)-5 b(h,)67
+ b Fu(Soft)-5 b(w)g(are)66 b(Pip)5 b(elining)p Fx(,)65
+ b(reconstructs)g(the)i(lo)5 b(op)0 6211 y(suc)-5 b(h)41
+ b(that)f(eac)-5 b(h)41 b(iteration)e(of)i(the)g(lo)5
+ b(op)40 b(is)h(executed)f(at)h(a)g(constan)-5 b(t)40
+ b(in)-5 b(terv)-10 b(al,)43 b(pro)5 b(ducing)40 b(an)i(optimal)d(sc)-5
+ b(hedule.)0 6576 y(This)49 b(approac)-5 b(h)50 b(aims)e(to)i(k)-5
+ b(eep)49 b(the)g(pro)5 b(cessor's)49 b(pip)5 b(eline)48
+ b(full)g(and)i(ultimately)d(sp)5 b(eed)49 b(up)h(the)f(execution)f
+ (time)0 6942 y(of)60 b(the)g(program.)282 7307 y(Soft)-5
+ b(w)g(are)64 b(Pip)5 b(elining)62 b(has)i(existed)f(for)i(man)-5
+ b(y)63 b(y)-5 b(ears)64 b(and)h(has)f(b)5 b(een)64 b(pro)-5
+ b(v)g(en)65 b(to)f(b)5 b(e)64 b(a)h(viable)e(sc)-5 b(heduling)0
+ 7672 y(solution)72 b(for)i(VLIW)g(\(V)-15 b(ery)73 b(Long)h
+ (Instruction)e(W)-15 b(ord\))74 b(and)g(sup)5 b(erscalar)73
+ b(arc)-5 b(hitectures.)118 b(As)75 b(more)e(arc)-5 b(hi-)0
+ 8038 y(tectures)67 b(emerge)g(that)g(pro)-5 b(vide)67
+ b(supp)5 b(ort)68 b(for)g(Soft)-5 b(w)g(are)67 b(Pip)5
+ b(elining)65 b([20,)i(24,)g(37],)i(existing)d(algorithms)g(are)0
+ 8403 y(b)5 b(eing)60 b(re\014ned,)g(and)g(new)h(tec)-5
+ b(hniques)59 b(are)i(b)5 b(eing)59 b(dev)-5 b(elop)5
+ b(ed.)282 8768 y(In)65 b(the)f(early)h(da)-5 b(ys)64
+ b(of)h(Soft)-5 b(w)g(are)64 b(Pip)5 b(elining,)63 b(the)i(tec)-5
+ b(hniques)63 b(w)-5 b(ould)64 b(sc)-5 b(hedule)64 b(instructions)f
+ (from)h(sev-)0 9134 y(eral)70 b(iterations)f(and)h(lo)5
+ b(ok)71 b(for)f(a)h(pattern)f([36)o(].)110 b Fu(Mo)5
+ b(dulo)70 b(Sc)-5 b(heduling)69 b Fx(is)h(a)h(family)d(of)i(Soft)-5
+ b(w)g(are)70 b(Pip)5 b(elining)0 9499 y(tec)-5 b(hniques)60
+ b(that)g(uses)h(a)g(\\mo)5 b(dulo")60 b(tec)-5 b(hnique)60
+ b(\(instead)g(of)h(maximal)e(unrolling\))h(to)h(place)f(instructions)f
+ (in)0 9865 y(the)e(sc)-5 b(hedule)56 b(suc)-5 b(h)56
+ b(that)h(when)g(iterations)e(are)j(o)-5 b(v)g(erlapp)5
+ b(ed)56 b(there)h(are)g(no)g(resource)g(or)g(data)g(con\015icts.)77
+ b(This)0 10230 y(thesis)48 b(describ)5 b(es)49 b(an)h(implemen)-5
+ b(tation)46 b(and)k(extension)e(of)i(one)f(suc)-5 b(h)50
+ b(algorithm,)f Fu(Swing)h(Mo)5 b(dulo)49 b(Sc)-5 b(heduling)p
+ Fx(.)3855 11136 y(1)p eop end
+ %%Page: 2 9
+ TeXDict begin 2 8 bop 0 183 a Ft(1.1)270 b(Mo)7 b(dulo)92
+ b(Sc)-7 b(heduling)0 728 y Fx(The)48 b(idea)e(b)5 b(ehind)47
+ b(Mo)5 b(dulo)47 b(Sc)-5 b(heduling)46 b(can)h(easily)f(b)5
+ b(e)47 b(illustrated)e(with)i(the)g(follo)-5 b(wing)46
+ b(example.)74 b(Figure)47 b(1.1)0 1093 y(sho)-5 b(ws)64
+ b(a)h(sequence)e(of)h(instructions)f(that)g(represen)-5
+ b(t)64 b(the)g(b)5 b(o)g(dy)65 b(of)f(a)g(lo)5 b(op.)92
+ b(Assume)64 b(that)g(this)f(sequence)h(of)0 1459 y(instructions)d
+ (reads)i(a)g(v)-10 b(alue)62 b(from)g(an)h(arra)-5 b(y)-15
+ b(,)64 b(adds)e(some)g(constan)-5 b(t)62 b(to)h(that)f(v)-10
+ b(alue,)63 b(and)g(stores)f(that)g(v)-10 b(alue.)0 1824
+ y(F)-15 b(or)72 b(this)f(simple)g(example,)i(there)f(are)g(only)g(data)
+ g(dep)5 b(endences)71 b(within)g(one)h(iteration,)h(since)e(subsequen)
+ -5 b(t)0 2190 y(iterations)59 b(access)g(a)h(di\013eren)-5
+ b(t)60 b(elemen)-5 b(t)59 b(within)h(the)g(same)f(arra)-5
+ b(y)-15 b(.)3626 2641 y Fs(1)196 b(load)3626 2823 y(2)g(add)3626
+ 3006 y(3)3626 3189 y(4)g(store)2407 3708 y Fx(Figure)60
+ b(1.1:)79 b(Single)60 b(Iteration)f(of)h(a)g(Lo)5 b(op)282
+ 4158 y(Assume)79 b(that)g(the)g(add)g(instruction)f(is)h(a)g
+ (single-stage)e(pip)5 b(elined)78 b(op)5 b(eration)78
+ b(that)h(tak)-5 b(es)79 b(t)-5 b(w)g(o)79 b(cycles,)0
+ 4523 y(while)k(the)f(load)h(and)g(store)g(b)5 b(oth)83
+ b(tak)-5 b(e)83 b(one)g(cycle.)148 b(As)83 b(y)-5 b(ou)83
+ b(can)g(see)g(the)g(original)f(lo)5 b(op)83 b(tak)-5
+ b(es)82 b(4)h(cycles)0 4888 y(b)5 b(et)-5 b(w)g(een)60
+ b(the)g(initiation)e(of)i(eac)-5 b(h)60 b(iteration.)282
+ 5254 y(Mo)5 b(dulo)70 b(Sc)-5 b(heduling)69 b(attempts)f(to)i(minimize)
+ e(the)i(time)f(b)5 b(et)-5 b(w)g(een)70 b(initiations)d(of)j(lo)5
+ b(op)70 b(iterations,)g(and)0 5619 y(lo)-5 b(w)g(er)72
+ b(the)g(o)-5 b(v)g(erall)71 b(execution)g(time)g(of)h(the)g(lo)5
+ b(op.)115 b(It)72 b(do)5 b(es)72 b(this)f(b)-5 b(y)73
+ b(mo)5 b(difying)70 b(the)i(lo)5 b(op)72 b(suc)-5 b(h)72
+ b(that)f(there)0 5984 y(are)62 b(no)f(resource)h(or)f(data)h
+ (con\015icts)e(and)i(attempts)d(to)j(k)-5 b(eep)61 b(the)g(pro)5
+ b(cessor's)61 b(pip)5 b(eline)60 b(constan)-5 b(tly)60
+ b(full)g(\(i.e.)0 6350 y(no)k(stalls\).)89 b(Figure)63
+ b(1.2)h(sho)-5 b(ws)64 b(ho)-5 b(w)64 b(the)g(co)5 b(de)64
+ b(is)f(structured)h(in)-5 b(to)63 b(three)h(sections)e(suc)-5
+ b(h)64 b(that)f(the)h(ramp)g(up)0 6715 y(stage)53 b(b)5
+ b(egins)52 b(to)h(\014ll)g(the)g(pip)5 b(eline,)53 b(steady)f(state)h
+ (is)f(reac)-5 b(hed)54 b(where)f(the)g(pip)5 b(eline)52
+ b(is)h(alw)-5 b(a)g(ys)53 b(full,)g(and)g(\014nally)0
+ 7081 y(it)75 b(ramps)h(do)-5 b(wn)76 b(as)f(the)h(pip)5
+ b(eline)74 b(empties)g(and)i(the)g(lo)5 b(op)75 b(terminates.)124
+ b(The)77 b(goal)e(is)g(to)h(ensure)f(that)g(the)0 7446
+ y(ma)10 b(jorit)-5 b(y)59 b(of)h(the)g(execution)f(time)g(is)h(sp)5
+ b(en)-5 b(t)60 b(in)g(steady)g(state.)282 7811 y(The)54
+ b(lo)5 b(op)54 b(is)f(reconstructed)g(in)-5 b(to)53 b(3)h(comp)5
+ b(onen)-5 b(ts)53 b([31)o(])h(related)f(to)g(the)h(pattern)f(describ)5
+ b(ed)53 b(in)h(Figure)f(1.2:)273 8368 y Fr(\017)91 b
+ Fx(Prologue:)79 b(A)61 b(sequence)e(of)h(instructions)f(leading)g(to)h
+ (steady)g(state.)273 8880 y Fr(\017)91 b Fx(Kernel:)118
+ b(Instructions)78 b(that)h(are)h(executed)f(on)g(ev)-5
+ b(ery)80 b(cycle)f(of)g(the)g(lo)5 b(op)79 b(once)h(its)f(reac)-5
+ b(hed)79 b(steady)455 9246 y(state.)273 9758 y Fr(\017)91
+ b Fx(Epilogue:)78 b(Instructions)59 b(that)h(are)g(executed)g(to)g
+ (\014nish)g(the)g(lo)5 b(op.)282 10315 y(Using)64 b(the)g(example)f(in)
+ h(Figure)g(1.1,)g(if)g(w)-5 b(e)64 b(lo)5 b(ok)64 b(at)g(4)h
+ (iterations)d(of)i(the)g(lo)5 b(op)64 b(and)h(pic)-5
+ b(k)63 b(an)i(instruction)0 10680 y(from)60 b(eac)-5
+ b(h)60 b(iteration,)e(w)-5 b(e)61 b(can)f(form)g(a)h(k)-5
+ b(ernel.)3855 11136 y(2)p eop end
+ %%Page: 3 10
+ TeXDict begin 3 9 bop 0 0 a
+  23681433 10893456 3289088 34206515 33680261 48349593 startTexFig
+  0 0 a
+ %%BeginDocument: figs/SteadyState.ps
+ %!PS-Adobe-3.0
+ %%Title: (SteadyState.pdf)
+ %%Version: 1 4
+ %%Creator: (\376\377)
+ %%CreationDate: (D:20050503133227-05'00')
+ %%DocumentData: Clean7Bit
+ %%LanguageLevel: 2
+ %%BoundingBox: 50 520 512 735
+ %%Pages: 1
+ %%DocumentProcessColors: (atend)
+ %%DocumentSuppliedResources: (atend)
+ %%EndComments
+ %%BeginDefaults
+ %%EndDefaults
+ %%BeginProlog
+ %%EndProlog
+ %%BeginSetup
+ %%BeginResource: l2check
+ %%Copyright: Copyright 1993 Adobe Systems Incorporated. All Rights Reserved.
+ systemdict /languagelevel known
+ { systemdict /languagelevel get 1 eq }
+ { true }
+ ifelse
+ {
+ initgraphics /Helvetica findfont 18 scalefont setfont
+ 72 600 moveto (Error: Your printer driver needs to be configured) dup show
+ 72 580 moveto (for printing to a PostScript Language Level 1 printer.) dup show
+ exch = =
+ /Helvetica-Bold findfont 16 scalefont setfont
+ 72 520 moveto (Windows and Unix) show
+ /Times-Roman findfont 16 scalefont setfont
+ 72 500 moveto (Select ?Language Level 1? in the PostScript options section) show
+ 72 480 moveto (of the Acrobat print dialog.) show
+ /Helvetica-Bold findfont 16 scalefont setfont
+ 72 440 moveto (Macintosh) show
+ /Times-Roman findfont 16 scalefont setfont
+ 72 420 moveto (In the Chooser, select your printer driver.) show
+ 72 400 moveto (Then select your printer and click the Setup button.) show
+ 72 380 moveto (Follow any on-screen dialogs that may appear.) show
+ showpage
+ quit
+ }
+ if
+ %%EndResource
+ userdict /pdf_svglb currentglobal put true setglobal
+ %%BeginResource: file Pscript_CFF PSVER
+ userdict/ct_CffDict 6 dict put ct_CffDict begin/F0Subr{systemdict/internaldict
+ known{1183615869 systemdict/internaldict get exec/FlxProc known{save true}{
+ false}ifelse}{userdict/internaldict known not{userdict/internaldict{count 0 eq
+ {/internaldict errordict/invalidaccess get exec}if dup type/integertype ne{
+ /internaldict errordict/invalidaccess get exec}if dup 1183615869 eq{pop 0}{
+ /internaldict errordict/invalidaccess get exec}ifelse}dup 14 get 1 25 dict put
+ bind executeonly put}if 1183615869 userdict/internaldict get exec/FlxProc
+ known{save true}{false}ifelse}ifelse[systemdict/internaldict known not{100
+ dict/begin cvx/mtx matrix/def cvx}if systemdict/currentpacking known{
+ currentpacking true setpacking}if{systemdict/internaldict known{1183615869
+ systemdict/internaldict get exec dup/$FlxDict known not{dup dup length exch
+ maxlength eq{pop userdict dup/$FlxDict known not{100 dict begin/mtx matrix def
+ dup/$FlxDict currentdict put end}if}{100 dict begin/mtx matrix def dup
+ /$FlxDict currentdict put end}ifelse}if/$FlxDict get begin}if grestore/exdef{
+ exch def}def/dmin exch abs 100 div def/epX exdef/epY exdef/c4y2 exdef/c4x2
+ exdef/c4y1 exdef/c4x1 exdef/c4y0 exdef/c4x0 exdef/c3y2 exdef/c3x2 exdef/c3y1
+ exdef/c3x1 exdef/c3y0 exdef/c3x0 exdef/c1y2 exdef/c1x2 exdef/c2x2 c4x2 def
+ /c2y2 c4y2 def/yflag c1y2 c3y2 sub abs c1x2 c3x2 sub abs gt def/PickCoords{{
+ c1x0 c1y0 c1x1 c1y1 c1x2 c1y2 c2x0 c2y0 c2x1 c2y1 c2x2 c2y2}{c3x0 c3y0 c3x1
+ c3y1 c3x2 c3y2 c4x0 c4y0 c4x1 c4y1 c4x2 c4y2}ifelse/y5 exdef/x5 exdef/y4 exdef
+ /x4 exdef/y3 exdef/x3 exdef/y2 exdef/x2 exdef/y1 exdef/x1 exdef/y0 exdef/x0
+ exdef}def mtx currentmatrix pop mtx 0 get abs 1e-05 lt mtx 3 get abs 1e-05 lt
+ or{/flipXY -1 def}{mtx 1 get abs 1e-05 lt mtx 2 get abs 1e-05 lt or{/flipXY 1
+ def}{/flipXY 0 def}ifelse}ifelse/erosion 1 def systemdict/internaldict known{
+ 1183615869 systemdict/internaldict get exec dup/erosion known{/erosion get
+ /erosion exch def}{pop}ifelse}if yflag{flipXY 0 eq c3y2 c4y2 eq or{false
+ PickCoords}{/shrink c3y2 c4y2 eq{0}{c1y2 c4y2 sub c3y2 c4y2 sub div abs}ifelse
+ def/yshrink{c4y2 sub shrink mul c4y2 add}def/c1y0 c3y0 yshrink def/c1y1 c3y1
+ yshrink def/c2y0 c4y0 yshrink def/c2y1 c4y1 yshrink def/c1x0 c3x0 def/c1x1
+ c3x1 def/c2x0 c4x0 def/c2x1 c4x1 def/dY 0 c3y2 c1y2 sub round dtransform
+ flipXY 1 eq{exch}if pop abs def dY dmin lt PickCoords y2 c1y2 sub abs .001 gt{
+ c1x2 c1y2 transform flipXY 1 eq{exch}if/cx exch def/cy exch def/dY 0 y2 c1y2
+ sub round dtransform flipXY 1 eq{exch}if pop def dY round dup 0 ne{/dY exdef}{
+ pop dY 0 lt{-1}{1}ifelse/dY exdef}ifelse/erode PaintType 2 ne erosion .5 ge
+ and def erode{/cy cy .5 sub def}if/ey cy dY add def/ey ey ceiling ey sub ey
+ floor add def erode{/ey ey .5 add def}if ey cx flipXY 1 eq{exch}if itransform
+ exch pop y2 sub/eShift exch def/y1 y1 eShift add def/y2 y2 eShift add def/y3
+ y3 eShift add def}if}ifelse}{flipXY 0 eq c3x2 c4x2 eq or{false PickCoords}{
+ /shrink c3x2 c4x2 eq{0}{c1x2 c4x2 sub c3x2 c4x2 sub div abs}ifelse def/xshrink
+ {c4x2 sub shrink mul c4x2 add}def/c1x0 c3x0 xshrink def/c1x1 c3x1 xshrink def
+ /c2x0 c4x0 xshrink def/c2x1 c4x1 xshrink def/c1y0 c3y0 def/c1y1 c3y1 def/c2y0
+ c4y0 def/c2y1 c4y1 def/dX c3x2 c1x2 sub round 0 dtransform flipXY -1 eq{exch}
+ if pop abs def dX dmin lt PickCoords x2 c1x2 sub abs .001 gt{c1x2 c1y2
+ transform flipXY -1 eq{exch}if/cy exch def/cx exch def/dX x2 c1x2 sub round 0
+ dtransform flipXY -1 eq{exch}if pop def dX round dup 0 ne{/dX exdef}{pop dX 0
+ lt{-1}{1}ifelse/dX exdef}ifelse/erode PaintType 2 ne erosion .5 ge and def
+ erode{/cx cx .5 sub def}if/ex cx dX add def/ex ex ceiling ex sub ex floor add
+ def erode{/ex ex .5 add def}if ex cy flipXY -1 eq{exch}if itransform pop x2
+ sub/eShift exch def/x1 x1 eShift add def/x2 x2 eShift add def/x3 x3 eShift add
+ def}if}ifelse}ifelse x2 x5 eq y2 y5 eq or{x5 y5 lineto}{x0 y0 x1 y1 x2 y2
+ curveto x3 y3 x4 y4 x5 y5 curveto}ifelse epY epX}systemdict/currentpacking
+ known{exch setpacking}if/exec cvx/end cvx]cvx executeonly exch{pop true exch
+ restore}{systemdict/internaldict known not{1183615869 userdict/internaldict
+ get exec exch/FlxProc exch put true}{1183615869 systemdict/internaldict get
+ exec dup length exch maxlength eq{false}{1183615869 systemdict/internaldict
+ get exec exch/FlxProc exch put true}ifelse}ifelse}ifelse{systemdict
+ /internaldict known{1183615869 systemdict/internaldict get exec/FlxProc get
+ exec}{1183615869 userdict/internaldict get exec/FlxProc get exec}ifelse}if}
+ executeonly def/F1Subr{gsave currentpoint newpath moveto}bind def/F2Subr{
+ currentpoint grestore gsave currentpoint newpath moveto}bind def/HSSubr{
+ systemdict/internaldict known not{pop 3}{1183615869 systemdict/internaldict
+ get exec dup/startlock known{/startlock get exec}{dup/strtlck known{/strtlck
+ get exec}{pop 3}ifelse}ifelse}ifelse}bind def end
+ %%EndResource
+ 
+ userdict /pdf_svglb get setglobal
+ /currentpacking where{pop currentpacking true setpacking}if
+ %%BeginResource: procset pdfvars
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Version: 5.0 6
+ %%Title: definition of dictionary of variables used by PDF & PDFText procsets
+ userdict /PDF 160 dict put
+ userdict /PDFVars 89 dict dup begin put
+ /docSetupDone false def
+ /InitAll 0 def
+ /TermAll 0 def
+ /DocInitAll 0 def
+ /DocTermAll 0 def
+ /_pdfEncodings 2 array def
+ /_pdf_str1 1 string def
+ /_pdf_i 0 def
+ /_pdf_na 0 def
+ /_pdf_showproc 0 def
+ /_italMtx [1 0 .212557 1 0 0] def
+ /_italMtx_WMode1 [1 -.212557 0 1 0 0] def
+ /_italMtxType0 [1 0 .1062785 1 0 0] def
+ /_italMtx_WMode1Type0 [1 -.1062785 0 1 0 0] def
+ /_basefont 0 def
+ /_basefonto 0 def
+ /_pdf_oldCIDInit null def
+ /_pdf_FontDirectory 30 dict def
+ /_categories 10 dict def
+ /_sa? true def
+ /_ColorSep5044? false def
+ /nulldict 0 dict def
+ /_processColors 0 def
+ /overprintstack null def
+ /_defaulttransfer currenttransfer def
+ /_defaultflatness currentflat def
+ /_defaulthalftone null def
+ /_defaultcolortransfer null def
+ /_defaultblackgeneration null def
+ /_defaultundercolorremoval null def
+ /_defaultcolortransfer null def
+ PDF begin
+ [/c/cs/cm/d/d0/f/h/i/j/J/l/m/M/n/q/Q/re/ri/S/sc/sh/Tf/w/W
+ /applyInterpFunc/applystitchFunc/domainClip/encodeInput
+ /initgs/int/limit/rangeClip
+ /defineRes/findRes/setSA/pl
+ %% to keep CoolType entries in GlyphDirProcs safe from collisions with Win PS driver
+ /? /! /| /: /+ /GetGlyphDirectory
+ /pdf_flushFilters /pdf_readstring /pdf_dictOp /pdf_image /pdf_maskedImage
+ /pdf_shfill /pdf_sethalftone
+ ] {null def} bind forall
+ end
+ end
+ %%EndResource
+ PDFVars begin PDF begin
+ %%BeginResource: procset pdfutil
+ %%Copyright: Copyright 1993-1999 Adobe Systems Incorporated. All Rights Reserved.
+ %%Version: 4.0 2
+ %%Title: Basic utilities used by other PDF procsets
+ /bd {bind def} bind def
+ /ld {load def} bd
+ /bld {
+ dup length dict begin
+ { null def } forall
+ bind
+ end
+ def
+ } bd
+ /dd { PDFVars 3 1 roll put } bd
+ /xdd { exch dd } bd
+ /Level2?
+ systemdict /languagelevel known
+ { systemdict /languagelevel get 2 ge } { false } ifelse
+ def
+ /Level1? Level2? not def
+ /Level3?
+ systemdict /languagelevel known
+ {systemdict /languagelevel get 3 eq } { false } ifelse
+ def
+ /getifknown {
+ 2 copy known { get true } { pop pop false } ifelse
+ } bd
+ /here {
+ currentdict exch getifknown
+ } bd
+ /isdefined? { where { pop true } { false } ifelse } bd
+ %%EndResource
+ %%BeginResource: procset pdf
+ %%Version: 5.0 7
+ %%Copyright: Copyright 1998-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Title: General operators for PDF, common to all Language Levels.
+ /cm { matrix astore concat } bd
+ /d /setdash ld
+ /f /fill ld
+ /h /closepath ld
+ /i {dup 0 eq {pop _defaultflatness} if setflat} bd
+ /j /setlinejoin ld
+ /J /setlinecap ld
+ /M /setmiterlimit ld
+ /n /newpath ld
+ /S /stroke ld
+ /w /setlinewidth ld
+ /W /clip ld
+ /initgs {
+ 0 setgray
+ [] 0 d
+ 0 j
+ 0 J
+ 10 M
+ 1 w
+ false setSA
+ /_defaulttransfer load settransfer
+ 0 i
+ /RelativeColorimetric ri
+ newpath
+ } bd
+ /int {
+ dup 2 index sub 3 index 5 index sub div 6 -2 roll sub mul
+ exch pop add exch pop
+ } bd
+ /limit {
+ dup 2 index le { exch } if pop
+ dup 2 index ge { exch } if pop
+ } bd
+ /domainClip {
+ Domain aload pop 3 2 roll
+ limit
+ } [/Domain] bld
+ /applyInterpFunc {
+ 0 1 DimOut 1 sub
+ {
+ dup C0 exch get exch
+ dup C1 exch get exch
+ 3 1 roll
+ 1 index sub
+ 3 index
+ N exp mul add
+ exch
+ currentdict /Range_lo known
+ {
+ dup Range_lo exch get exch
+ Range_hi exch get
+ 3 2 roll limit
+ }
+ {
+ pop
+ }
+ ifelse
+ exch
+ } for
+ pop
+ } [/DimOut /C0 /C1 /N /Range_lo /Range_hi] bld
+ /encodeInput {
+ NumParts 1 sub
+ 0 1 2 index
+ {
+ dup Bounds exch get
+ 2 index gt
+ { exit }
+ { dup
+ 3 index eq
+ { exit }
+ { pop } ifelse
+ } ifelse
+ } for
+ 3 2 roll pop
+ dup Bounds exch get exch
+ dup 1 add Bounds exch get exch
+ 2 mul
+ dup Encode exch get exch
+ 1 add Encode exch get
+ int
+ } [/NumParts /Bounds /Encode] bld
+ /rangeClip {
+ exch dup Range_lo exch get
+ exch Range_hi exch get
+ 3 2 roll
+ limit
+ } [/Range_lo /Range_hi] bld
+ /applyStitchFunc {
+ Functions exch get exec
+ currentdict /Range_lo known {
+ 0 1 DimOut 1 sub {
+ DimOut 1 add -1 roll
+ rangeClip
+ } for
+ } if
+ } [/Functions /Range_lo /DimOut] bld
+ /pdf_flushfilters
+ {
+ aload length
+ { dup status
+ 1 index currentfile ne and
+ { dup flushfile closefile }
+ { pop }
+ ifelse
+ } repeat
+ } bd
+ /pdf_readstring
+ {
+ 1 index dup length 1 sub get
+ exch readstring pop
+ exch pdf_flushfilters
+ } bind def
+ /pdf_dictOp
+ {
+ 3 2 roll
+ 10 dict copy
+ begin
+ _Filters dup length 1 sub get def
+ currentdict exch exec
+ _Filters pdf_flushfilters
+ end
+ } [/_Filters] bld
+ /pdf_image {{image} /DataSource pdf_dictOp} bd
+ /pdf_imagemask {{imagemask} /DataSource pdf_dictOp} bd
+ /pdf_shfill {{sh} /DataSource pdf_dictOp} bd
+ /pdf_sethalftone {{sethalftone} /Thresholds pdf_dictOp} bd
+ /pdf_maskedImage
+ {
+ 10 dict copy begin
+ /miDict currentdict def
+ /DataDict DataDict 10 dict copy def
+ DataDict begin
+ /DataSource
+ _Filters dup length 1 sub get
+ def
+ miDict image
+ _Filters pdf_flushfilters
+ end
+ end
+ } [/miDict /DataDict /_Filters] bld
+ /RadialShade {
+ 40 dict begin
+ /background exch def
+ /ext1 exch def
+ /ext0 exch def
+ /BBox exch def
+ /r2 exch def
+ /c2y exch def
+ /c2x exch def
+ /r1 exch def
+ /c1y exch def
+ /c1x exch def
+ /rampdict exch def
+ gsave
+ BBox length 0 gt {
+ newpath
+ BBox 0 get BBox 1 get moveto
+ BBox 2 get BBox 0 get sub 0 rlineto
+ 0 BBox 3 get BBox 1 get sub rlineto
+ BBox 2 get BBox 0 get sub neg 0 rlineto
+ closepath
+ clip
+ newpath
+ } if
+ c1x c2x eq
+ {
+ c1y c2y lt {/theta 90 def}{/theta 270 def} ifelse
+ }
+ {
+ /slope c2y c1y sub c2x c1x sub div def
+ /theta slope 1 atan def
+ c2x c1x lt c2y c1y ge and { /theta theta 180 sub def} if
+ c2x c1x lt c2y c1y lt and { /theta theta 180 add def} if
+ }
+ ifelse
+ gsave
+ clippath
+ c1x c1y translate
+ theta rotate
+ -90 rotate
+ { pathbbox } stopped
+ { 0 0 0 0 } if
+ /yMax exch def
+ /xMax exch def
+ /yMin exch def
+ /xMin exch def
+ grestore
+ xMax xMin eq yMax yMin eq or
+ {
+ grestore
+ end
+ }
+ {
+ rampdict begin
+ 40 dict begin
+ background length 0 gt { background sssetbackground gsave clippath fill grestore } if
+ gsave
+ c1x c1y translate
+ theta rotate
+ -90 rotate
+ /c2y c1x c2x sub dup mul c1y c2y sub dup mul add sqrt def
+ /c1y 0 def
+ /c1x 0 def
+ /c2x 0 def
+ ext0 {
+ 0 getrampcolor
+ c2y r2 add r1 lt
+ {
+ c1x c1y r1 360 0 arcn
+ xMin yMin moveto
+ xMax yMin lineto
+ xMax yMax lineto
+ xMin yMax lineto
+ xMin yMin lineto
+ eofill
+ }
+ {
+ c2y r1 add r2 le
+ {
+ c1x c1y r1 0 360 arc
+ fill
+ }
+ {
+ c2x c2y r2 0 360 arc fill
+ r1 r2 eq
+ {
+ /p1x r1 neg def
+ /p1y c1y def
+ /p2x r1 def
+ /p2y c1y def
+ p1x p1y moveto p2x p2y lineto p2x yMin lineto p1x yMin lineto
+ fill
+ }
+ {
+ /AA r2 r1 sub c2y div def
+ /theta AA 1 AA dup mul sub sqrt div 1 atan def
+ /SS1 90 theta add dup sin exch cos div def
+ /p1x r1 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def
+ /p1y p1x SS1 div neg def
+ /SS2 90 theta sub dup sin exch cos div def
+ /p2x r1 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def
+ /p2y p2x SS2 div neg def
+ r1 r2 gt
+ {
+ /L1maxX p1x yMin p1y sub SS1 div add def
+ /L2maxX p2x yMin p2y sub SS2 div add def
+ }
+ {
+ /L1maxX 0 def
+ /L2maxX 0 def
+ }ifelse
+ p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto
+ L1maxX L1maxX p1x sub SS1 mul p1y add lineto
+ fill
+ }
+ ifelse
+ }
+ ifelse
+ } ifelse
+ } if
+ c1x c2x sub dup mul
+ c1y c2y sub dup mul
+ add 0.5 exp
+ 0 dtransform
+ dup mul exch dup mul add 0.5 exp 72 div
+ 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 1 index 1 index lt { exch } if pop
+ /hires exch def
+ hires mul
+ /numpix exch def
+ /numsteps NumSamples def
+ /rampIndxInc 1 def
+ /subsampling false def
+ numpix 0 ne
+ {
+ NumSamples numpix div 0.5 gt
+ {
+ /numsteps numpix 2 div round cvi dup 1 le { pop 2 } if def
+ /rampIndxInc NumSamples 1 sub numsteps div def
+ /subsampling true def
+ } if
+ } if
+ /xInc c2x c1x sub numsteps div def
+ /yInc c2y c1y sub numsteps div def
+ /rInc r2 r1 sub numsteps div def
+ /cx c1x def
+ /cy c1y def
+ /radius r1 def
+ newpath
+ xInc 0 eq yInc 0 eq rInc 0 eq and and
+ {
+ 0 getrampcolor
+ cx cy radius 0 360 arc
+ stroke
+ NumSamples 1 sub getrampcolor
+ cx cy radius 72 hires div add 0 360 arc
+ 0 setlinewidth
+ stroke
+ }
+ {
+ 0
+ numsteps
+ {
+ dup
+ subsampling { round cvi } if
+ getrampcolor
+ cx cy radius 0 360 arc
+ /cx cx xInc add def
+ /cy cy yInc add def
+ /radius radius rInc add def
+ cx cy radius 360 0 arcn
+ eofill
+ rampIndxInc add
+ }
+ repeat
+ pop
+ } ifelse
+ ext1 {
+ c2y r2 add r1 lt
+ {
+ c2x c2y r2 0 360 arc
+ fill
+ }
+ {
+ c2y r1 add r2 le
+ {
+ c2x c2y r2 360 0 arcn
+ xMin yMin moveto
+ xMax yMin lineto
+ xMax yMax lineto
+ xMin yMax lineto
+ xMin yMin lineto
+ eofill
+ }
+ {
+ c2x c2y r2 0 360 arc fill
+ r1 r2 eq
+ {
+ /p1x r2 neg def
+ /p1y c2y def
+ /p2x r2 def
+ /p2y c2y def
+ p1x p1y moveto p2x p2y lineto p2x yMax lineto p1x yMax lineto
+ fill
+ }
+ {
+ /AA r2 r1 sub c2y div def
+ /theta AA 1 AA dup mul sub sqrt div 1 atan def
+ /SS1 90 theta add dup sin exch cos div def
+ /p1x r2 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def
+ /p1y c2y p1x SS1 div sub def
+ /SS2 90 theta sub dup sin exch cos div def
+ /p2x r2 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def
+ /p2y c2y p2x SS2 div sub def
+ r1 r2 lt
+ {
+ /L1maxX p1x yMax p1y sub SS1 div add def
+ /L2maxX p2x yMax p2y sub SS2 div add def
+ }
+ {
+ /L1maxX 0 def
+ /L2maxX 0 def
+ }ifelse
+ p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto
+ L1maxX L1maxX p1x sub SS1 mul p1y add lineto
+ fill
+ }
+ ifelse
+ }
+ ifelse
+ } ifelse
+ } if
+ grestore
+ grestore
+ end
+ end
+ end
+ } ifelse
+ } bd
+ /GenStrips {
+ 40 dict begin
+ /background exch def
+ /ext1 exch def
+ /ext0 exch def
+ /BBox exch def
+ /y2 exch def
+ /x2 exch def
+ /y1 exch def
+ /x1 exch def
+ /rampdict exch def
+ gsave
+ BBox length 0 gt {
+ newpath
+ BBox 0 get BBox 1 get moveto
+ BBox 2 get BBox 0 get sub 0 rlineto
+ 0 BBox 3 get BBox 1 get sub rlineto
+ BBox 2 get BBox 0 get sub neg 0 rlineto
+ closepath
+ clip
+ newpath
+ } if
+ x1 x2 eq
+ {
+ y1 y2 lt {/theta 90 def}{/theta 270 def} ifelse
+ }
+ {
+ /slope y2 y1 sub x2 x1 sub div def
+ /theta slope 1 atan def
+ x2 x1 lt y2 y1 ge and { /theta theta 180 sub def} if
+ x2 x1 lt y2 y1 lt and { /theta theta 180 add def} if
+ }
+ ifelse
+ gsave
+ clippath
+ x1 y1 translate
+ theta rotate
+ { pathbbox } stopped
+ { 0 0 0 0 } if
+ /yMax exch def
+ /xMax exch def
+ /yMin exch def
+ /xMin exch def
+ grestore
+ xMax xMin eq yMax yMin eq or
+ {
+ grestore
+ end
+ }
+ {
+ rampdict begin
+ 20 dict begin
+ background length 0 gt { background sssetbackground gsave clippath fill grestore } if
+ gsave
+ x1 y1 translate
+ theta rotate
+ /xStart 0 def
+ /xEnd x2 x1 sub dup mul y2 y1 sub dup mul add 0.5 exp def
+ /ySpan yMax yMin sub def
+ /numsteps NumSamples def
+ /rampIndxInc 1 def
+ /subsampling false def
+ xStart 0 transform
+ xEnd 0 transform
+ 3 -1 roll
+ sub dup mul
+ 3 1 roll
+ sub dup mul
+ add 0.5 exp 72 div
+ 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 1 index 1 index lt { exch } if pop
+ mul
+ /numpix exch def
+ numpix 0 ne
+ {
+ NumSamples numpix div 0.5 gt
+ {
+ /numsteps numpix 2 div round cvi dup 1 le { pop 2 } if def
+ /rampIndxInc NumSamples 1 sub numsteps div def
+ /subsampling true def
+ } if
+ } if
+ ext0 {
+ 0 getrampcolor
+ xMin xStart lt
+ { xMin yMin xMin neg ySpan rectfill } if
+ } if
+ /xInc xEnd xStart sub numsteps div def
+ /x xStart def
+ 0
+ numsteps
+ {
+ dup
+ subsampling { round cvi } if
+ getrampcolor
+ x yMin xInc ySpan rectfill
+ /x x xInc add def
+ rampIndxInc add
+ }
+ repeat
+ pop
+ ext1 {
+ xMax xEnd gt
+ { xEnd yMin xMax xEnd sub ySpan rectfill } if
+ } if
+ grestore
+ grestore
+ end
+ end
+ end
+ } ifelse
+ } bd
+ %%EndResource
+ %%BeginResource: procset pdflev2
+ %%Version: 5.0 15
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%LanguageLevel: 2
+ %%Title: PDF operators, with code specific for Level 2
+ /docinitialize {
+ PDF begin
+ /_defaulthalftone currenthalftone dd
+ /_defaultblackgeneration currentblackgeneration dd
+ /_defaultundercolorremoval currentundercolorremoval dd
+ /_defaultcolortransfer [currentcolortransfer] dd
+ /_defaulttransfer currenttransfer dd
+ end
+ PDFVars /docSetupDone true put
+ } bd
+ /initialize {
+ PDFVars /docSetupDone get {
+ _defaulthalftone sethalftone
+ /_defaultblackgeneration load setblackgeneration
+ /_defaultundercolorremoval load setundercolorremoval
+ _defaultcolortransfer aload pop setcolortransfer
+ } if
+ false setoverprint
+ } bd
+ /terminate { } bd
+ /c /curveto ld
+ /cs /setcolorspace ld
+ /l /lineto ld
+ /m /moveto ld
+ /q /gsave ld
+ /Q /grestore ld
+ /sc /setcolor ld
+ /setSA/setstrokeadjust ld
+ /re {
+ 4 2 roll m
+ 1 index 0 rlineto
+ 0 exch rlineto
+ neg 0 rlineto
+ h
+ } bd
+ /concattransferfuncs {
+ [ 3 1 roll /exec load exch /exec load ] cvx
+ } bd
+ /concatandsettransfer {
+ /_defaulttransfer load concattransferfuncs settransfer
+ } bd
+ /concatandsetcolortransfer {
+ _defaultcolortransfer aload pop
+ 8 -1 roll 5 -1 roll concattransferfuncs 7 1 roll
+ 6 -1 roll 4 -1 roll concattransferfuncs 5 1 roll
+ 4 -1 roll 3 -1 roll concattransferfuncs 3 1 roll
+ concattransferfuncs
+ setcolortransfer
+ } bd
+ /defineRes/defineresource ld
+ /findRes/findresource ld
+ currentglobal
+ true systemdict /setglobal get exec
+ [/Function /ExtGState /Form /Shading /FunctionDictionary /MadePattern /PatternPrototype /DataSource /Image]
+ { /Generic /Category findresource dup length dict copy /Category defineresource pop }
+ forall
+ systemdict /setglobal get exec
+ /ri
+ {
+ /findcolorrendering isdefined?
+ {
+ mark exch
+ findcolorrendering
+ counttomark 2 eq
+ { type /booleantype eq
+ { dup type /nametype eq
+ { dup /ColorRendering resourcestatus
+ { pop pop
+ dup /DefaultColorRendering ne
+ {
+ /ColorRendering findresource
+ setcolorrendering
+ } if
+ } if
+ } if
+ } if
+ } if
+ cleartomark
+ }
+ { pop
+ } ifelse
+ } bd
+ /knownColorants? {
+ pop false
+ } bd
+ /getrampcolor {
+ /indx exch def
+ 0 1 NumComp 1 sub {
+ dup
+ Samples exch get
+ dup type /stringtype eq { indx get } if
+ exch
+ Scaling exch get aload pop
+ 3 1 roll
+ mul add
+ } for
+ setcolor
+ } bd
+ /sssetbackground { aload pop setcolor } bd
+ %%EndResource
+ %%BeginResource: procset pdftext
+ %%Version: 5.0 6
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Title: Text operators for PDF
+ PDF /PDFText 78 dict dup begin put
+ /docinitialize
+ {
+ /resourcestatus where {
+ pop
+ /CIDParams /ProcSet resourcestatus {
+ pop pop
+ false /CIDParams /ProcSet findresource /SetBuildCompatible get exec
+ } if
+ } if
+ PDF begin
+ PDFText /_pdfDefineIdentity-H known
+ { PDFText /_pdfDefineIdentity-H get exec}
+ if
+ end
+ } bd
+ /initialize {
+ PDFText begin
+ } bd
+ /terminate { end } bd
+ Level2?
+ {
+ /_safeput
+ {
+ 3 -1 roll load 3 1 roll put
+ }
+ bd
+ }
+ {
+ /_safeput
+ {
+ 2 index load dup dup length exch maxlength ge
+ { dup length 5 add dict copy
+ 3 index xdd
+ }
+ { pop }
+ ifelse
+ 3 -1 roll load 3 1 roll put
+ }
+ bd
+ }
+ ifelse
+ /pdf_has_composefont? systemdict /composefont known def
+ /CopyFont {
+ {
+ 1 index /FID ne 2 index /UniqueID ne and
+ { def } { pop pop } ifelse
+ } forall
+ } bd
+ /Type0CopyFont
+ {
+ exch
+ dup length dict
+ begin
+ CopyFont
+ [
+ exch
+ FDepVector
+ {
+ dup /FontType get 0 eq
+ {
+ 1 index Type0CopyFont
+ /_pdfType0 exch definefont
+ }
+ {
+ /_pdfBaseFont exch
+ 2 index exec
+ }
+ ifelse
+ exch
+ }
+ forall
+ pop
+ ]
+ /FDepVector exch def
+ currentdict
+ end
+ } bd
+ Level2? {currentglobal true setglobal} if
+ /cHexEncoding
+ [/c00/c01/c02/c03/c04/c05/c06/c07/c08/c09/c0A/c0B/c0C/c0D/c0E/c0F/c10/c11/c12
+ /c13/c14/c15/c16/c17/c18/c19/c1A/c1B/c1C/c1D/c1E/c1F/c20/c21/c22/c23/c24/c25
+ /c26/c27/c28/c29/c2A/c2B/c2C/c2D/c2E/c2F/c30/c31/c32/c33/c34/c35/c36/c37/c38
+ /c39/c3A/c3B/c3C/c3D/c3E/c3F/c40/c41/c42/c43/c44/c45/c46/c47/c48/c49/c4A/c4B
+ /c4C/c4D/c4E/c4F/c50/c51/c52/c53/c54/c55/c56/c57/c58/c59/c5A/c5B/c5C/c5D/c5E
+ /c5F/c60/c61/c62/c63/c64/c65/c66/c67/c68/c69/c6A/c6B/c6C/c6D/c6E/c6F/c70/c71
+ /c72/c73/c74/c75/c76/c77/c78/c79/c7A/c7B/c7C/c7D/c7E/c7F/c80/c81/c82/c83/c84
+ /c85/c86/c87/c88/c89/c8A/c8B/c8C/c8D/c8E/c8F/c90/c91/c92/c93/c94/c95/c96/c97
+ /c98/c99/c9A/c9B/c9C/c9D/c9E/c9F/cA0/cA1/cA2/cA3/cA4/cA5/cA6/cA7/cA8/cA9/cAA
+ /cAB/cAC/cAD/cAE/cAF/cB0/cB1/cB2/cB3/cB4/cB5/cB6/cB7/cB8/cB9/cBA/cBB/cBC/cBD
+ /cBE/cBF/cC0/cC1/cC2/cC3/cC4/cC5/cC6/cC7/cC8/cC9/cCA/cCB/cCC/cCD/cCE/cCF/cD0
+ /cD1/cD2/cD3/cD4/cD5/cD6/cD7/cD8/cD9/cDA/cDB/cDC/cDD/cDE/cDF/cE0/cE1/cE2/cE3
+ /cE4/cE5/cE6/cE7/cE8/cE9/cEA/cEB/cEC/cED/cEE/cEF/cF0/cF1/cF2/cF3/cF4/cF5/cF6
+ /cF7/cF8/cF9/cFA/cFB/cFC/cFD/cFE/cFF] def
+ Level2? {setglobal} if
+ /modEnc {
+ /_enc xdd
+ /_icode 0 dd
+ counttomark 1 sub -1 0
+ {
+ index
+ dup type /nametype eq
+ {
+ _enc _icode 3 -1 roll put
+ _icode 1 add
+ }
+ if
+ /_icode xdd
+ } for
+ cleartomark
+ _enc
+ } bd
+ /trEnc {
+ /_enc xdd
+ 255 -1 0 {
+ exch dup -1 eq
+ { pop /.notdef }
+ { Encoding exch get }
+ ifelse
+ _enc 3 1 roll put
+ } for
+ pop
+ _enc
+ } bd
+ /TE {
+ /_i xdd
+ StandardEncoding 256 array copy modEnc
+ _pdfEncodings exch _i exch put
+ } bd
+ /TZ
+ {
+ /_usePDFEncoding xdd
+ findfont
+ dup length 6 add dict
+ begin
+ {
+ 1 index /FID ne { def } { pop pop } ifelse
+ } forall
+ /pdf_origFontName FontName def
+ /FontName exch def
+ currentdict /PaintType known
+ { PaintType 2 eq {/PaintType 0 def} if }
+ if
+ _usePDFEncoding 0 ge
+ {
+ /Encoding _pdfEncodings _usePDFEncoding get def
+ pop
+ }
+ {
+ _usePDFEncoding -1 eq
+ {
+ counttomark 0 eq
+ { pop }
+ {
+ Encoding 256 array copy
+ modEnc /Encoding exch def
+ }
+ ifelse
+ }
+ {
+ 256 array
+ trEnc /Encoding exch def
+ }
+ ifelse
+ }
+ ifelse
+ pdf_EuroProcSet pdf_origFontName known
+ {
+ pdf_origFontName pdf_AddEuroGlyphProc
+ } if
+ Level2?
+ {
+ currentdict /pdf_origFontName undef
+ } if
+ FontName currentdict
+ end
+ definefont pop
+ }
+ bd
+ Level2?
+ {
+ /TZG
+ {
+ currentglobal true setglobal
+ 2 index _pdfFontStatus
+ {
+ 2 index findfont
+ false setglobal
+ 3 index findfont
+ true setglobal
+ ne
+ {
+ 2 index findfont dup rcheck
+ {
+ dup length dict begin
+ {
+ 1 index /FID ne { def } { pop pop } ifelse
+ } forall
+ currentdict end
+ }
+ if
+ 3 index exch definefont pop
+ }
+ if
+ } if
+ setglobal
+ TZ
+ } bd
+ }
+ {
+ /TZG {TZ} bd
+ } ifelse
+ Level2?
+ {
+ currentglobal false setglobal
+ userdict /pdftext_data 5 dict put
+ pdftext_data
+ begin
+ /saveStacks
+ {
+ pdftext_data
+ begin
+ /vmmode currentglobal def
+ false setglobal
+ count array astore /os exch def
+ end
+ countdictstack array dictstack pdftext_data exch /ds exch put
+ cleardictstack pdftext_data /dscount countdictstack put
+ pdftext_data /vmmode get setglobal
+ } bind def
+ /restoreStacks
+ {
+ pdftext_data /vmmode currentglobal put false setglobal
+ clear cleardictstack
+ pdftext_data /ds get dup
+ pdftext_data /dscount get 1 2 index length 1 sub
+ { get begin dup } for
+ pop pop
+ pdftext_data /os get aload pop
+ pdftext_data /vmmode get setglobal
+ } bind def
+ /testForClonePrinterBug
+ {
+ currentglobal true setglobal
+ /undefinedCategory /Generic /Category findresource
+ dup length dict copy /Category defineresource pop
+ setglobal
+ pdftext_data /saveStacks get exec
+ pdftext_data /vmmode currentglobal put false setglobal
+ /undefined /undefinedCategory { resourcestatus } stopped
+ pdftext_data exch /bugFound exch put
+ pdftext_data /vmmode get setglobal
+ pdftext_data /restoreStacks get exec
+ pdftext_data /bugFound get
+ } bind def
+ end
+ setglobal
+ /pdf_resourcestatus
+ pdftext_data /testForClonePrinterBug get exec
+ {
+ {
+ pdftext_data /saveStacks get exec
+ pdftext_data /os get dup dup length 1 sub
+ dup 1 sub dup 0 lt { pop 0 } if
+ exch 1 exch { get exch dup } for
+ pop pop
+ { resourcestatus }
+ stopped
+ {
+ clear cleardictstack pdftext_data /restoreStacks get exec
+ { pop pop } stopped pop false
+ }
+ {
+ count array astore pdftext_data exch /results exch put
+ pdftext_data /restoreStacks get exec pop pop
+ pdftext_data /results get aload pop
+ }
+ ifelse
+ }
+ }
+ { { resourcestatus } }
+ ifelse
+ bd
+ }
+ if
+ Level2?
+ {
+ /_pdfUndefineResource
+ {
+ currentglobal 3 1 roll
+ _pdf_FontDirectory 2 index 2 copy known
+ {undef}
+ {pop pop}
+ ifelse
+ 1 index (pdf) exch _pdfConcatNames 1 index
+ 1 index 1 _pdfConcatNames 1 index
+ 5 index 1 _pdfConcatNames 1 index
+ 4
+ {
+ 2 copy pdf_resourcestatus
+ {
+ pop 2 lt
+ {2 copy findresource gcheck setglobal undefineresource}
+ {pop pop}
+ ifelse
+ }
+ { pop pop}
+ ifelse
+ } repeat
+ setglobal
+ } bd
+ }
+ {
+ /_pdfUndefineResource { pop pop} bd
+ }
+ ifelse
+ Level2?
+ {
+ /_pdfFontStatus
+ {
+ currentglobal exch
+ /Font pdf_resourcestatus
+ {pop pop true}
+ {false}
+ ifelse
+ exch setglobal
+ } bd
+ }
+ {
+ /_pdfFontStatusString 50 string def
+ _pdfFontStatusString 0 (fonts/) putinterval
+ /_pdfFontStatus
+ {
+ FontDirectory 1 index known
+ { pop true }
+ {
+ _pdfFontStatusString 6 42 getinterval
+ cvs length 6 add
+ _pdfFontStatusString exch 0 exch getinterval
+ { status } stopped
+ {pop false}
+ {
+ { pop pop pop pop true}
+ { false }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ ifelse
+ Level2?
+ {
+ /_pdfCIDFontStatus
+ {
+ /CIDFont /Category pdf_resourcestatus
+ {
+ pop pop
+ /CIDFont pdf_resourcestatus
+ {pop pop true}
+ {false}
+ ifelse
+ }
+ { pop false }
+ ifelse
+ } bd
+ }
+ if
+ /_pdfString100 100 string def
+ /_pdfComposeFontName
+ {
+ dup length 1 eq
+ {
+ 0 get
+ 1 index
+ type /nametype eq
+ {
+ _pdfString100 cvs
+ length dup dup _pdfString100 exch (-) putinterval
+ _pdfString100 exch 1 add dup _pdfString100 length exch sub getinterval
+ 2 index exch cvs length
+ add 1 add _pdfString100 exch 0 exch getinterval
+ exch pop
+ true
+ }
+ {
+ pop pop
+ false
+ }
+ ifelse
+ }
+ {
+ false
+ }
+ ifelse
+ dup {exch cvn exch} if
+ } bd
+ /_pdfConcatNames
+ {
+ exch
+ _pdfString100 cvs
+ length dup dup _pdfString100 exch (-) putinterval
+ _pdfString100 exch 1 add dup _pdfString100 length exch sub getinterval
+ 3 -1 roll exch cvs length
+ add 1 add _pdfString100 exch 0 exch getinterval
+ cvn
+ } bind def
+ /_pdfTextTempString 50 string def
+ /_pdfRegOrderingArray [(Adobe-Japan1) (Adobe-CNS1) (Adobe-Korea1) (Adobe-GB1)] def
+ /_pdf_CheckCIDSystemInfo
+ {
+ 1 index _pdfTextTempString cvs
+ (Identity) anchorsearch
+ {
+ pop pop pop pop true
+ }
+ {
+ false
+ _pdfRegOrderingArray
+ {
+ 2 index exch
+ anchorsearch
+ { pop pop pop true exit}
+ { pop }
+ ifelse
+ }
+ forall
+ exch pop
+ exch /CIDFont findresource
+ /CIDSystemInfo get
+ 3 -1 roll /CMap findresource
+ /CIDSystemInfo get
+ exch
+ 3 -1 roll
+ {
+ 2 copy
+ /Supplement get
+ exch
+ dup type /dicttype eq
+ {/Supplement get}
+ {pop 0 }
+ ifelse
+ ge
+ }
+ { true }
+ ifelse
+ {
+ dup /Registry get
+ 2 index /Registry get eq
+ {
+ /Ordering get
+ exch /Ordering get
+ dup type /arraytype eq
+ {
+ 1 index type /arraytype eq
+ {
+ true
+ 1 index length 1 sub -1 0
+ {
+ dup 2 index exch get exch 3 index exch get ne
+ { pop false exit}
+ if
+ } for
+ exch pop exch pop
+ }
+ { pop pop false }
+ ifelse
+ }
+ {
+ eq
+ }
+ ifelse
+ }
+ { pop pop false }
+ ifelse
+ }
+ { pop pop false }
+ ifelse
+ }
+ ifelse
+ } bind def
+ pdf_has_composefont?
+ {
+ /_pdfComposeFont
+ {
+ 2 copy _pdfComposeFontName not
+ {
+ 2 index
+ }
+ if
+ (pdf) exch _pdfConcatNames
+ dup _pdfFontStatus
+ { dup findfont 5 2 roll pop pop pop true}
+ {
+ 4 1 roll
+ 1 index /CMap pdf_resourcestatus
+ {
+ pop pop
+ true
+ }
+ {false}
+ ifelse
+ 1 index true exch
+ {
+ _pdfCIDFontStatus not
+ {pop false exit}
+ if
+ }
+ forall
+ and
+ {
+ 1 index 1 index 0 get _pdf_CheckCIDSystemInfo
+ {
+ 3 -1 roll pop
+ 2 index 3 1 roll
+ composefont true
+ }
+ {
+ pop pop exch pop false
+ }
+ ifelse
+ }
+ {
+ _pdfComposeFontName
+ {
+ dup _pdfFontStatus
+ {
+ exch pop
+ 1 index exch
+ findfont definefont true
+ }
+ {
+ pop exch pop
+ false
+ }
+ ifelse
+ }
+ {
+ exch pop
+ false
+ }
+ ifelse
+ }
+ ifelse
+ { true }
+ {
+ dup _pdfFontStatus
+ { dup findfont true }
+ { pop false }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ {
+ /_pdfComposeFont
+ {
+ _pdfComposeFontName not
+ {
+ dup
+ }
+ if
+ dup
+ _pdfFontStatus
+ {exch pop dup findfont true}
+ {
+ 1 index
+ dup type /nametype eq
+ {pop}
+ {cvn}
+ ifelse
+ eq
+ {pop false}
+ {
+ dup _pdfFontStatus
+ {dup findfont true}
+ {pop false}
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ ifelse
+ /_pdfStyleDicts 4 dict dup begin
+ /Adobe-Japan1 4 dict dup begin
+ Level2?
+ {
+ /Serif
+ /HeiseiMin-W3-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiMin-W3}
+ {
+ /HeiseiMin-W3 _pdfCIDFontStatus
+ {/HeiseiMin-W3}
+ {/Ryumin-Light}
+ ifelse
+ }
+ ifelse
+ def
+ /SansSerif
+ /HeiseiKakuGo-W5-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiKakuGo-W5}
+ {
+ /HeiseiKakuGo-W5 _pdfCIDFontStatus
+ {/HeiseiKakuGo-W5}
+ {/GothicBBB-Medium}
+ ifelse
+ }
+ ifelse
+ def
+ /HeiseiMaruGo-W4-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiMaruGo-W4}
+ {
+ /HeiseiMaruGo-W4 _pdfCIDFontStatus
+ {/HeiseiMaruGo-W4}
+ {
+ /Jun101-Light-RKSJ-H _pdfFontStatus
+ { /Jun101-Light }
+ { SansSerif }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ /RoundSansSerif exch def
+ /Default Serif def
+ }
+ {
+ /Serif /Ryumin-Light def
+ /SansSerif /GothicBBB-Medium def
+ {
+ (fonts/Jun101-Light-83pv-RKSJ-H) status
+ }stopped
+ {pop}{
+ { pop pop pop pop /Jun101-Light }
+ { SansSerif }
+ ifelse
+ /RoundSansSerif exch def
+ }ifelse
+ /Default Serif def
+ }
+ ifelse
+ end
+ def
+ /Adobe-Korea1 4 dict dup begin
+ /Serif /HYSMyeongJo-Medium def
+ /SansSerif /HYGoThic-Medium def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ /Adobe-GB1 4 dict dup begin
+ /Serif /STSong-Light def
+ /SansSerif /STHeiti-Regular def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ /Adobe-CNS1 4 dict dup begin
+ /Serif /MKai-Medium def
+ /SansSerif /MHei-Medium def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ end
+ def
+ /TZzero
+ {
+ /_wmode xdd
+ /_styleArr xdd
+ /_regOrdering xdd
+ 3 copy
+ _pdfComposeFont
+ {
+ 5 2 roll pop pop pop
+ }
+ {
+ [
+ 0 1 _styleArr length 1 sub
+ {
+ _styleArr exch get
+ _pdfStyleDicts _regOrdering 2 copy known
+ {
+ get
+ exch 2 copy known not
+ { pop /Default }
+ if
+ get
+ }
+ {
+ pop pop pop /Unknown
+ }
+ ifelse
+ }
+ for
+ ]
+ exch pop
+ 2 index 3 1 roll
+ _pdfComposeFont
+ {3 -1 roll pop}
+ {
+ findfont dup /FontName get exch
+ }
+ ifelse
+ }
+ ifelse
+ dup /WMode 2 copy known
+ { get _wmode ne }
+ { pop pop _wmode 1 eq}
+ ifelse
+ {
+ exch _wmode _pdfConcatNames
+ dup _pdfFontStatus
+ { exch pop dup findfont false}
+ { exch true }
+ ifelse
+ }
+ {
+ dup /FontType get 0 ne
+ }
+ ifelse
+ {
+ dup /FontType get 3 eq _wmode 1 eq and
+ {
+ _pdfVerticalRomanT3Font dup length 10 add dict copy
+ begin
+ /_basefont exch
+ dup length 3 add dict
+ begin
+ {1 index /FID ne {def}{pop pop} ifelse }
+ forall
+ /Encoding Encoding dup length array copy
+ dup 16#27 /quotesingle put
+ dup 16#60 /grave put
+ _regOrdering /Adobe-Japan1 eq
+ {dup 16#5c /yen put dup 16#a5 /yen put dup 16#b4 /yen put}
+ if
+ def
+ FontName
+ currentdict
+ end
+ definefont
+ def
+ /Encoding _basefont /Encoding get def
+ /_fauxfont true def
+ }
+ {
+ dup length 3 add dict
+ begin
+ {1 index /FID ne {def}{pop pop} ifelse }
+ forall
+ FontType 0 ne
+ {
+ /Encoding Encoding dup length array copy
+ dup 16#27 /quotesingle put
+ dup 16#60 /grave put
+ _regOrdering /Adobe-Japan1 eq
+ {dup 16#5c /yen put}
+ if
+ def
+ /_fauxfont true def
+ } if
+ } ifelse
+ /WMode _wmode def
+ dup dup /FontName exch def
+ currentdict
+ end
+ definefont pop
+ }
+ {
+ pop
+ }
+ ifelse
+ /_pdf_FontDirectory 3 1 roll _safeput
+ }
+ bd
+ Level2?
+ {
+ /Tf {
+ _pdf_FontDirectory 2 index 2 copy known
+ {get exch 3 -1 roll pop}
+ {pop pop}
+ ifelse
+ selectfont
+ } bd
+ }
+ {
+ /Tf {
+ _pdf_FontDirectory 2 index 2 copy known
+ {get exch 3 -1 roll pop}
+ {pop pop}
+ ifelse
+ exch findfont exch
+ dup type /arraytype eq
+ {makefont}
+ {scalefont}
+ ifelse
+ setfont
+ } bd
+ }
+ ifelse
+ /cshow where
+ {
+ pop /pdf_cshow /cshow load dd
+ /pdf_remove2 {pop pop} dd
+ }
+ {
+ /pdf_cshow {exch forall} dd
+ /pdf_remove2 {} dd
+ } ifelse
+ /pdf_xshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ _pdf_x _pdf_y moveto
+ 0
+ rmoveto
+ }
+ ifelse
+ _pdf_i 1 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdf_yshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ _pdf_x _pdf_y moveto
+ 0 exch
+ rmoveto
+ }
+ ifelse
+ _pdf_i 1 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdf_xyshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ {_pdf_na _pdf_i 1 add get} stopped
+ { pop pop pop}
+ {
+ _pdf_x _pdf_y moveto
+ rmoveto
+ }
+ ifelse
+ }
+ ifelse
+ _pdf_i 2 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdfl1xs {/_pdf_showproc /show load dd pdf_xshow} bd
+ /pdfl1ys {/_pdf_showproc /show load dd pdf_yshow} bd
+ /pdfl1xys {/_pdf_showproc /show load dd pdf_xyshow} bd
+ Level2? _ColorSep5044? not and
+ {
+ /pdfxs {{xshow} stopped {pdfl1xs} if} bd
+ /pdfys {{yshow} stopped {pdfl1ys} if} bd
+ /pdfxys {{xyshow} stopped {pdfl1xys} if} bd
+ }
+ {
+ /pdfxs /pdfl1xs load dd
+ /pdfys /pdfl1ys load dd
+ /pdfxys /pdfl1xys load dd
+ } ifelse
+ /pdf_charpath {false charpath} bd
+ /pdf_xcharpath {/_pdf_showproc /pdf_charpath load dd pdf_xshow} bd
+ /pdf_ycharpath {/_pdf_showproc /pdf_charpath load dd pdf_yshow} bd
+ /pdf_xycharpath {/_pdf_showproc /pdf_charpath load dd pdf_xyshow} bd
+ /pdf_strokepath
+ {
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 false charpath
+ currentpoint S moveto
+ } bind
+ exch pdf_cshow
+ } bd
+ /pdf_xstrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_xshow} bd
+ /pdf_ystrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_yshow} bd
+ /pdf_xystrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_xyshow} bd
+ Level2? {currentglobal true setglobal} if
+ /d0/setcharwidth ld
+ /nND {{/.notdef} repeat} bd
+ /T3Defs {
+ /BuildChar
+ {
+ 1 index /Encoding get exch get
+ 1 index /BuildGlyph get exec
+ }
+ def
+ /BuildGlyph {
+ exch begin
+ GlyphProcs exch get exec
+ end
+ } def
+ /_pdfT3Font true def
+ } bd
+ /_pdfBoldRomanWidthProc
+ {
+ stringwidth 1 index 0 ne { exch .03 add exch }if setcharwidth
+ 0 0
+ } bd
+ /_pdfType0WidthProc
+ {
+ dup stringwidth 0 0 moveto
+ 2 index true charpath pathbbox
+ 0 -1
+ 7 index 2 div .88
+ setcachedevice2
+ pop
+ 0 0
+ } bd
+ /_pdfType0WMode1WidthProc
+ {
+ dup stringwidth
+ pop 2 div neg -0.88
+ 2 copy
+ moveto
+ 0 -1
+ 5 -1 roll true charpath pathbbox
+ setcachedevice
+ } bd
+ /_pdfBoldBaseFont
+ 11 dict begin
+ /FontType 3 def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /Encoding cHexEncoding def
+ /_setwidthProc /_pdfBoldRomanWidthProc load def
+ /_bcstr1 1 string def
+ /BuildChar
+ {
+ exch begin
+ _basefont setfont
+ _bcstr1 dup 0 4 -1 roll put
+ dup
+ _setwidthProc
+ 3 copy
+ moveto
+ show
+ _basefonto setfont
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ pdf_has_composefont?
+ {
+ /_pdfBoldBaseCIDFont
+ 11 dict begin
+ /CIDFontType 1 def
+ /CIDFontName /_pdfBoldBaseCIDFont def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /_setwidthProc /_pdfType0WidthProc load def
+ /_bcstr2 2 string def
+ /BuildGlyph
+ {
+ exch begin
+ _basefont setfont
+ _bcstr2 1 2 index 256 mod put
+ _bcstr2 0 3 -1 roll 256 idiv put
+ _bcstr2 dup _setwidthProc
+ 3 copy
+ moveto
+ show
+ _basefonto setfont
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ /_pdfDefineIdentity-H
+ {
+ /Identity-H /CMap PDFText /pdf_resourcestatus get exec
+ {
+ pop pop
+ }
+ {
+ /CIDInit/ProcSet findresource begin 12 dict begin
+ begincmap
+ /CIDSystemInfo
+ 3 dict begin
+ /Registry (Adobe) def
+ /Ordering (Identity) def
+ /Supplement 0 def
+ currentdict
+ end
+ def
+ /CMapName /Identity-H def
+ /CMapVersion 1 def
+ /CMapType 1 def
+ 1 begincodespacerange
+ <0000> 
+ endcodespacerange
+ 1 begincidrange
+ <0000>  0
+ endcidrange
+ endcmap
+ CMapName currentdict/CMap defineresource pop
+ end
+ end
+ } ifelse
+ } def
+ } if
+ /_pdfVerticalRomanT3Font
+ 10 dict begin
+ /FontType 3 def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /_bcstr1 1 string def
+ /BuildChar
+ {
+ exch begin
+ _basefont setfont
+ _bcstr1 dup 0 4 -1 roll put
+ dup
+ _pdfType0WidthProc
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ Level2? {setglobal} if
+ /MakeBoldFont
+ {
+ dup /ct_SyntheticBold known
+ {
+ dup length 3 add dict begin
+ CopyFont
+ /ct_StrokeWidth .03 0 FontMatrix idtransform pop def
+ /ct_SyntheticBold true def
+ currentdict
+ end
+ definefont
+ }
+ {
+ dup dup length 3 add dict
+ begin
+ CopyFont
+ /PaintType 2 def
+ /StrokeWidth .03 0 FontMatrix idtransform pop def
+ /dummybold currentdict
+ end
+ definefont
+ dup /FontType get dup 9 ge exch 11 le and
+ {
+ _pdfBoldBaseCIDFont
+ dup length 3 add dict copy begin
+ dup /CIDSystemInfo get /CIDSystemInfo exch def
+ /_Type0Identity /Identity-H 3 -1 roll [ exch ] composefont
+ /_basefont exch def
+ /_Type0Identity /Identity-H 3 -1 roll [ exch ] composefont
+ /_basefonto exch def
+ currentdict
+ end
+ /CIDFont defineresource
+ }
+ {
+ _pdfBoldBaseFont
+ dup length 3 add dict copy begin
+ /_basefont exch def
+ /_basefonto exch def
+ currentdict
+ end
+ definefont
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ /MakeBold {
+ 1 index
+ _pdf_FontDirectory 2 index 2 copy known
+ {get}
+ {exch pop}
+ ifelse
+ findfont
+ dup
+ /FontType get 0 eq
+ {
+ dup /WMode known {dup /WMode get 1 eq }{false} ifelse
+ version length 4 ge
+ and
+ {version 0 4 getinterval cvi 2015 ge }
+ {true}
+ ifelse
+ {/_pdfType0WidthProc}
+ {/_pdfType0WMode1WidthProc}
+ ifelse
+ _pdfBoldBaseFont /_setwidthProc 3 -1 roll load put
+ {MakeBoldFont} Type0CopyFont definefont
+ }
+ {
+ dup /_fauxfont known not 1 index /SubstMaster known not and
+ {
+ _pdfBoldBaseFont /_setwidthProc /_pdfBoldRomanWidthProc load put
+ MakeBoldFont
+ }
+ {
+ 2 index 2 index eq
+ { exch pop }
+ {
+ dup length dict begin
+ CopyFont
+ currentdict
+ end
+ definefont
+ }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ pop pop
+ dup /dummybold ne
+ {/_pdf_FontDirectory exch dup _safeput }
+ { pop }
+ ifelse
+ }bd
+ /MakeItalic {
+ _pdf_FontDirectory exch 2 copy known
+ {get}
+ {exch pop}
+ ifelse
+ dup findfont
+ dup /FontInfo 2 copy known
+ {
+ get
+ /ItalicAngle 2 copy known
+ {get 0 eq }
+ { pop pop true}
+ ifelse
+ }
+ { pop pop true}
+ ifelse
+ {
+ exch pop
+ dup /FontType get 0 eq Level2? not and
+ { dup /FMapType get 6 eq }
+ { false }
+ ifelse
+ {
+ dup /WMode 2 copy known
+ {
+ get 1 eq
+ { _italMtx_WMode1Type0 }
+ { _italMtxType0 }
+ ifelse
+ }
+ { pop pop _italMtxType0 }
+ ifelse
+ }
+ {
+ dup /WMode 2 copy known
+ {
+ get 1 eq
+ { _italMtx_WMode1 }
+ { _italMtx }
+ ifelse
+ }
+ { pop pop _italMtx }
+ ifelse
+ }
+ ifelse
+ makefont
+ dup /FontType get 42 eq Level2? not or
+ {
+ dup length dict begin
+ CopyFont
+ currentdict
+ end
+ }
+ if
+ 1 index exch
+ definefont pop
+ /_pdf_FontDirectory exch dup _safeput
+ }
+ {
+ pop
+ 2 copy ne
+ {
+ /_pdf_FontDirectory 3 1 roll _safeput
+ }
+ { pop pop }
+ ifelse
+ }
+ ifelse
+ }bd
+ /MakeBoldItalic {
+ /dummybold exch
+ MakeBold
+ /dummybold
+ MakeItalic
+ }bd
+ Level2?
+ {
+ /pdf_CopyDict
+ {1 index length add dict copy}
+ def
+ }
+ {
+ /pdf_CopyDict
+ {
+ 1 index length add dict
+ 1 index wcheck
+ { copy }
+ { begin
+ {def} forall
+ currentdict
+ end
+ }
+ ifelse
+ }
+ def
+ }
+ ifelse
+ /pdf_AddEuroGlyphProc
+ {
+ currentdict /CharStrings known
+ {
+ CharStrings /Euro known not
+ {
+ dup
+ /CharStrings
+ CharStrings 1 pdf_CopyDict
+ begin
+ /Euro pdf_EuroProcSet 4 -1 roll get def
+ currentdict
+ end
+ def
+ /pdf_PSBuildGlyph /pdf_PSBuildGlyph load def
+ /pdf_PathOps /pdf_PathOps load def
+ /Symbol eq
+ {
+ /Encoding Encoding dup length array copy
+ dup 160 /Euro put def
+ }
+ if
+ }
+ { pop
+ }
+ ifelse
+ }
+ { pop
+ }
+ ifelse
+ }
+ def
+ Level2? {currentglobal true setglobal} if
+ /pdf_PathOps 4 dict dup begin
+ /m {moveto} def
+ /l {lineto} def
+ /c {curveto} def
+ /cp {closepath} def
+ end
+ def
+ /pdf_PSBuildGlyph
+ {
+ gsave
+ 8 -1 roll pop
+ 7 1 roll
+ currentdict /PaintType 2 copy known {get 2 eq}{pop pop false} ifelse
+ dup 9 1 roll
+ {
+ currentdict /StrokeWidth 2 copy known
+ {
+ get 2 div
+ 5 1 roll
+ 4 -1 roll 4 index sub
+ 4 1 roll
+ 3 -1 roll 4 index sub
+ 3 1 roll
+ exch 4 index add exch
+ 4 index add
+ 5 -1 roll pop
+ }
+ {
+ pop pop
+ }
+ ifelse
+ }
+ if
+ setcachedevice
+ pdf_PathOps begin
+ exec
+ end
+ {
+ currentdict /StrokeWidth 2 copy known
+ { get }
+ { pop pop 0 }
+ ifelse
+ setlinewidth stroke
+ }
+ {
+ fill
+ }
+ ifelse
+ grestore
+ } def
+ /pdf_EuroProcSet 13 dict def
+ pdf_EuroProcSet
+ begin
+ /Courier-Bold
+ {
+ 600 0 6 -12 585 612
+ {
+ 385 274 m
+ 180 274 l
+ 179 283 179 293 179 303 c
+ 179 310 179 316 180 323 c
+ 398 323 l
+ 423 404 l
+ 197 404 l
+ 219 477 273 520 357 520 c
+ 409 520 466 490 487 454 c
+ 487 389 l
+ 579 389 l
+ 579 612 l
+ 487 612 l
+ 487 560 l
+ 449 595 394 612 349 612 c
+ 222 612 130 529 98 404 c
+ 31 404 l
+ 6 323 l
+ 86 323 l
+ 86 304 l
+ 86 294 86 284 87 274 c
+ 31 274 l
+ 6 193 l
+ 99 193 l
+ 129 77 211 -12 359 -12 c
+ 398 -12 509 8 585 77 c
+ 529 145 l
+ 497 123 436 80 356 80 c
+ 285 80 227 122 198 193 c
+ 360 193 l
+ cp
+ 600 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Courier-BoldOblique /Courier-Bold load def
+ /Courier
+ {
+ 600 0 17 -12 578 584
+ {
+ 17 204 m
+ 97 204 l
+ 126 81 214 -12 361 -12 c
+ 440 -12 517 17 578 62 c
+ 554 109 l
+ 501 70 434 43 366 43 c
+ 266 43 184 101 154 204 c
+ 380 204 l
+ 400 259 l
+ 144 259 l
+ 144 270 143 281 143 292 c
+ 143 299 143 307 144 314 c
+ 418 314 l
+ 438 369 l
+ 153 369 l
+ 177 464 249 529 345 529 c
+ 415 529 484 503 522 463 c
+ 522 391 l
+ 576 391 l
+ 576 584 l
+ 522 584 l
+ 522 531 l
+ 473 566 420 584 348 584 c
+ 216 584 122 490 95 369 c
+ 37 369 l
+ 17 314 l
+ 87 314 l
+ 87 297 l
+ 87 284 88 272 89 259 c
+ 37 259 l
+ cp
+ 600 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Courier-Oblique /Courier load def
+ /Helvetica
+ {
+ 556 0 24 -19 541 703
+ {
+ 541 628 m
+ 510 669 442 703 354 703 c
+ 201 703 117 607 101 444 c
+ 50 444 l
+ 25 372 l
+ 97 372 l
+ 97 301 l
+ 49 301 l
+ 24 229 l
+ 103 229 l
+ 124 67 209 -19 350 -19 c
+ 435 -19 501 25 509 32 c
+ 509 131 l
+ 492 105 417 60 343 60 c
+ 267 60 204 127 197 229 c
+ 406 229 l
+ 430 301 l
+ 191 301 l
+ 191 372 l
+ 455 372 l
+ 479 444 l
+ 194 444 l
+ 201 531 245 624 348 624 c
+ 433 624 484 583 509 534 c
+ cp
+ 556 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Helvetica-Oblique /Helvetica load def
+ /Helvetica-Bold
+ {
+ 556 0 12 -19 563 710
+ {
+ 563 621 m
+ 537 659 463 710 363 710 c
+ 216 710 125 620 101 462 c
+ 51 462 l
+ 12 367 l
+ 92 367 l
+ 92 346 l
+ 92 337 93 328 93 319 c
+ 52 319 l
+ 12 224 l
+ 102 224 l
+ 131 58 228 -19 363 -19 c
+ 417 -19 471 -12 517 18 c
+ 517 146 l
+ 481 115 426 93 363 93 c
+ 283 93 254 166 246 224 c
+ 398 224 l
+ 438 319 l
+ 236 319 l
+ 236 367 l
+ 457 367 l
+ 497 462 l
+ 244 462 l
+ 259 552 298 598 363 598 c
+ 425 598 464 570 486 547 c
+ 507 526 513 517 517 509 c
+ cp
+ 556 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Helvetica-BoldOblique /Helvetica-Bold load def
+ /Symbol
+ {
+ 750 0 20 -12 714 685
+ {
+ 714 581 m
+ 650 645 560 685 465 685 c
+ 304 685 165 580 128 432 c
+ 50 432 l
+ 20 369 l
+ 116 369 l
+ 115 356 115 347 115 337 c
+ 115 328 115 319 116 306 c
+ 50 306 l
+ 20 243 l
+ 128 243 l
+ 165 97 300 -12 465 -12 c
+ 560 -12 635 25 685 65 c
+ 685 155 l
+ 633 91 551 51 465 51 c
+ 340 51 238 131 199 243 c
+ 555 243 l
+ 585 306 l
+ 184 306 l
+ 183 317 182 326 182 336 c
+ 182 346 183 356 184 369 c
+ 614 369 l 644 432 l
+ 199 432 l
+ 233 540 340 622 465 622 c
+ 555 622 636 580 685 520 c
+ cp
+ 750 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Bold
+ {
+ 500 0 16 -14 478 700
+ {
+ 367 308 m
+ 224 308 l
+ 224 368 l
+ 375 368 l
+ 380 414 l
+ 225 414 l
+ 230 589 257 653 315 653 c
+ 402 653 431 521 444 457 c
+ 473 457 l
+ 473 698 l
+ 444 697 l
+ 441 679 437 662 418 662 c
+ 393 662 365 700 310 700 c
+ 211 700 97 597 73 414 c
+ 21 414 l
+ 16 368 l
+ 69 368 l
+ 69 359 68 350 68 341 c
+ 68 330 68 319 69 308 c
+ 21 308 l
+ 16 262 l
+ 73 262 l
+ 91 119 161 -14 301 -14 c
+ 380 -14 443 50 478 116 c
+ 448 136 l
+ 415 84 382 40 323 40 c
+ 262 40 231 77 225 262 c
+ 362 262 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-BoldItalic
+ {
+ 500 0 9 -20 542 686
+ {
+ 542 686 m
+ 518 686 l
+ 513 673 507 660 495 660 c
+ 475 660 457 683 384 683 c
+ 285 683 170 584 122 430 c
+ 58 430 l
+ 34 369 l
+ 105 369 l
+ 101 354 92 328 90 312 c
+ 34 312 l
+ 9 251 l
+ 86 251 l
+ 85 238 84 223 84 207 c
+ 84 112 117 -14 272 -14 c
+ 326 -14 349 9 381 9 c
+ 393 9 393 -10 394 -20 c
+ 420 -20 l
+ 461 148 l
+ 429 148 l
+ 416 109 362 15 292 15 c
+ 227 15 197 55 197 128 c
+ 197 162 204 203 216 251 c
+ 378 251 l
+ 402 312 l
+ 227 312 l
+ 229 325 236 356 241 369 c
+ 425 369 l
+ 450 430 l
+ 255 430 l
+ 257 435 264 458 274 488 c
+ 298 561 337 654 394 654 c
+ 437 654 484 621 484 530 c
+ 484 516 l
+ 516 516 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Italic
+ {
+ 500 0 23 -10 595 692
+ {
+ 399 317 m
+ 196 317 l
+ 199 340 203 363 209 386 c
+ 429 386 l
+ 444 424 l
+ 219 424 l
+ 246 514 307 648 418 648 c
+ 448 648 471 638 492 616 c
+ 529 576 524 529 527 479 c
+ 549 475 l
+ 595 687 l
+ 570 687 l
+ 562 674 558 664 542 664 c
+ 518 664 474 692 423 692 c
+ 275 692 162 551 116 424 c
+ 67 424 l
+ 53 386 l
+ 104 386 l
+ 98 363 93 340 90 317 c
+ 37 317 l
+ 23 279 l
+ 86 279 l
+ 85 266 85 253 85 240 c
+ 85 118 137 -10 277 -10 c
+ 370 -10 436 58 488 128 c
+ 466 149 l
+ 424 101 375 48 307 48 c
+ 212 48 190 160 190 234 c
+ 190 249 191 264 192 279 c
+ 384 279 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Roman
+ {
+ 500 0 10 -12 484 692
+ {
+ 347 298 m
+ 171 298 l
+ 170 310 170 322 170 335 c
+ 170 362 l
+ 362 362 l
+ 374 403 l
+ 172 403 l
+ 184 580 244 642 308 642 c
+ 380 642 434 574 457 457 c
+ 481 462 l
+ 474 691 l
+ 449 691 l
+ 433 670 429 657 410 657 c
+ 394 657 360 692 299 692 c
+ 204 692 94 604 73 403 c
+ 22 403 l
+ 10 362 l
+ 70 362 l
+ 69 352 69 341 69 330 c
+ 69 319 69 308 70 298 c
+ 22 298 l
+ 10 257 l
+ 73 257 l
+ 97 57 216 -12 295 -12 c
+ 364 -12 427 25 484 123 c
+ 458 142 l
+ 425 101 384 37 316 37 c
+ 256 37 189 84 173 257 c
+ 335 257 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ end
+ Level2? {setglobal} if
+ currentdict readonly pop end
+ %%EndResource
+ PDFText begin
+ [userdict /pdf_svglb currentglobal put true setglobal
+ 39/quotesingle 96/grave 128/Adieresis/Aring/Ccedilla/Eacute/Ntilde/Odieresis
+ /Udieresis/aacute/agrave/acircumflex/adieresis/atilde/aring/ccedilla/eacute
+ /egrave/ecircumflex/edieresis/iacute/igrave/icircumflex/idieresis/ntilde
+ /oacute/ograve/ocircumflex/odieresis/otilde/uacute/ugrave/ucircumflex
+ /udieresis/dagger/degree/cent/sterling/section/bullet/paragraph/germandbls
+ /registered/copyright/trademark/acute/dieresis/.notdef/AE/Oslash
+ /.notdef/plusminus/.notdef/.notdef/yen/mu/.notdef/.notdef
+ /.notdef/.notdef/.notdef/ordfeminine/ordmasculine/.notdef/ae/oslash
+ /questiondown/exclamdown/logicalnot/.notdef/florin/.notdef/.notdef
+ /guillemotleft/guillemotright/ellipsis/space/Agrave/Atilde/Otilde/OE/oe
+ /endash/emdash/quotedblleft/quotedblright/quoteleft/quoteright/divide
+ /.notdef/ydieresis/Ydieresis/fraction/currency/guilsinglleft/guilsinglright
+ /fi/fl/daggerdbl/periodcentered/quotesinglbase/quotedblbase/perthousand
+ /Acircumflex/Ecircumflex/Aacute/Edieresis/Egrave/Iacute/Icircumflex
+ /Idieresis/Igrave/Oacute/Ocircumflex/.notdef/Ograve/Uacute/Ucircumflex
+ /Ugrave/dotlessi/circumflex/tilde/macron/breve/dotaccent/ring/cedilla
+ /hungarumlaut/ogonek/caron
+ 0 TE
+ [1/dotlessi/caron 39/quotesingle 96/grave 
+ 127/bullet/Euro/bullet/quotesinglbase/florin/quotedblbase/ellipsis
+ /dagger/daggerdbl/circumflex/perthousand/Scaron/guilsinglleft/OE
+ /bullet/Zcaron/bullet/bullet/quoteleft/quoteright/quotedblleft
+ /quotedblright/bullet/endash/emdash/tilde/trademark/scaron
+ /guilsinglright/oe/bullet/zcaron/Ydieresis/space/exclamdown/cent/sterling
+ /currency/yen/brokenbar/section/dieresis/copyright/ordfeminine
+ /guillemotleft/logicalnot/hyphen/registered/macron/degree/plusminus
+ /twosuperior/threesuperior/acute/mu/paragraph/periodcentered/cedilla
+ /onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters
+ /questiondown/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
+ /Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
+ /Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply/Oslash
+ /Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls/agrave
+ /aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla/egrave/eacute
+ /ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis/eth/ntilde
+ /ograve/oacute/ocircumflex/otilde/odieresis/divide/oslash/ugrave/uacute
+ /ucircumflex/udieresis/yacute/thorn/ydieresis
+ 1 TE
+ end
+ 
+ userdict /pdf_svglb get setglobal
+ currentdict readonly pop
+ end end
+ /currentpacking where {pop setpacking}if
+ PDFVars/DocInitAll{[PDF PDFText]{/docinitialize get exec}forall }put
+ PDFVars/InitAll{[PDF PDFText]{/initialize get exec}forall initgs}put
+ PDFVars/TermAll{[PDFText PDF]{/terminate get exec}forall}put
+ PDFVars begin PDF begin
+ PDFVars/DocInitAll get exec PDFVars/InitAll get exec
+ PDFVars/TermAll get exec end end
+ 
+ %%EndSetup
+ %%Page: 1 1
+ %%BeginPageSetup
+ userdict /pgsave save put
+ PDFVars begin PDF begin PDFVars/InitAll get exec
+ userdict /pdf_svglb currentglobal put true setglobal
+ %%BeginResource: font BAAAAA+NimbusRomNo9L-Regu
+ ct_CffDict begin
+ %!FontType1
+ 16 dict begin
+ /FontInfo 15 dict dup begin
+ /Notice (Copyright \050URW\051++,Copyright 1999 by \050URW\051++ Design & Development; Cyrillic glyphs added by Valek Filippov \050C\051 2001-2002; Numero, infinity and Omega made by Dmitry 40in \050C\051 2001) def
+ /version (1.06_2.0-11mdk) def
+ /FullName (Nimbus Roman No9 L Regular) def
+ /FamilyName (Nimbus Roman No9 L) def
+ /Weight (Regular) def
+ /ItalicAngle 0 def
+ /isFixedPitch false  def
+ /UnderlinePosition -100 def
+ /UnderlineThickness 50 def
+ end def
+ /FontName /BAAAAA+NimbusRomNo9L-Regu def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 0 /.notdef put
+  def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0 ] def
+ /FontBBox { -168 -281 1031 924 } def
+ /XUID [6 5020931 ] def
+ /StrokeWidth 0 def
+ currentdict end
+ currentfile eexec A0B00ED5187D9C0F1ECDF51878C3AA5CAA3EC8DC423323
+ 00A152553EC9C9C51591C81BB5A2F58753878D92B1C73E948BB360F467A7D593
+ 2446E52E22935D5D0316634839C917AE2BE363D6AE3760363F748EAAEAD9AB74
+ D863835F45718D23FB3980D0C645610BF765847F4BC5CB03391BDC9D40A6A460
+ ABF0D95BB6A176DB5088A1068A0DFDC266C25ADCBEF3E5472E03E0D29BC6801F
+ A2AEAD77E33C825D7C534A1D7572F4904734D34A8EB5CCBF6AF4BD16868351B4
+ 9720597C58AD9250B850406E3B7095164E634F096B16B87B7EB1DA7059CE66FD
+ DF08D200E8C5AE20931835F16D7D7ECCDC34AB3F57D265C90F7F578F7CDE6C42
+ 2B637C476D8C9107DAA4DE8D4F2D7F84152BD4AB55B2AA432180A64B4259F798
+ BA386ECF68D89017904276D1BA4C8960B5AAA290FE93C3918D5FD9CA6CD88F81
+ E8F1799E9F58531B9C9A5FEA211CACC738184F6C443AC8652A08F84DF4BCC249
+ B245F255FED27A3FD4E0008E595C9411DD61472EB9A6B76D3B97E3E86ECE9662
+ CDDBBBDFA8751F2980D4C7F34CAE666319E178677831A93AE607295D07B858E1
+ BF91E80DBF21975B1D2AE6AB7704A0A333902C55D72B1A68E1F83EC77A7155EF
+ F414607204C8D13586ED60035A3964A8BD3EAE97F01688677C49644A9DC05D73
+ 1DCA46F205AFBD07E21DDAA61B5CC76DD51ACBFAFB22A1A7CBB3ED35AA88785C
+ D6BDB6F0B4A3A88511E4C245E31F24A89CD0C73901AF2F97B52CC37BB93AA75B
+ AC51A455BF3D0419C309F18B2F21512D22A1FFBC26DA689B02EC6A156CC90220
+ 80CE0122B8484182F4DC68D202EEA7A385CD2C0602C6B06CA2423EF4E5B7A9FD
+ 8065F58DC20F0564BDC9FCF604482C6A9961C1BD4BAE67B66A0ED9F7588F56DD
+ 298327F7AFC3DD2E6B370AEDAC3A5EEB34BBA66F4969F8B4BE519A75D7C13C69
+ 14A9DE574E3E55B6473C33CF423DDCC61101E387245B975948CA2F8F8CF0328B
+ 532F07497A7DF747D34290588F915388C74E3C2FB5A4AB6938B198E51046FB8E
+ A62B5B50A2CFCAB0204487CBE7594C99E5FE0EE1F2119F31E302E0B83063FBB3
+ D450000EF21EC2E12F88C10E68A80B3EC4494C88781A6A9E604E916F626F167C
+ 98C1E2F844495404F9A72BE1E65839E5984036BE70DED7DD7FDCCB939CE0F0FE
+ C49C4BD7FF565C235C3DC010199F222C88A9068D8C75F6108BD777EBE007C372
+ AD292EB5A7B535AF33089C6FA236522441AA33E059DAC73E0B4A1EEC2D82E045
+ CB1AC8F10C892D9E9AD16F752629DE78F960AED22F4AEA1436DE4DCA9C26AFD8
+ C56499F70BAB90BDB0D89EAA59E31E1A7AA8F35E18C6844648FA14D72982A1C0
+ 1EA6B968C8A7861D67CB5518B7243677CBF8875AC60BA0463791531696D2DBC5
+ 4587334341431A8A061A553F4CF7D5369ED4BF95968FA73C63E5A9A8B7FD1AA5
+ 9CB121C1046586A2DCD4925CCBA76B767E7E4CDB7ED8A1CBC9A56F4EDFF61857
+ D8FF0CA6C39C82475053376AA2CCE5C7CAE5B023EF9D80989C971EE303B01AE7
+ D6730CAE40B82ADAB315FDB991F834E7F201B38249D5EFB2FC529F106DFB3907
+ B08FE77CE4A8E43EF9D09CF219D0764758D72BA189672759CE7CF8A58BAC0A7D
+ 5A7175462119B106EA55463DD4C110BC7FA69D33A5408A02FBC994009B6D5F7C
+ 54C16B1BBEAB0C04F215BD3783CDF915E2C1015F0191AFE7CCF51CD883AA8576
+ 86A237EFCFBE0C9851E4B4277C103C7F206A7234F1C0BCCB55C9C0304301B6A4
+ 301C34EABE7515DD1301657ED226325927EEE0379DAF9A80E445AA7CDC55C141
+ 9165E2ED0F3B025C3F12627C2266CEB1EBAE434DEAA5E89CBCA8B976A02E6CC6
+ CC37DA12B5AFF7300F909FD73A88E55F5FEC85310C6DADF134201F6CB7420106
+ 487DAB97B2DC88B90DD53ECA449D5A57ABCAA636A41923351149EEBC46545716
+ FF279DF1308F557A0A61339B0781AE88A3C4DC99233271726C1FA3A2277B5012
+ C800BA03AFD7CB70A7B61C3953EC02E20DD1214CBB8DBEF501A0FE578374434F
+ E5E38A2138F603702338CCCBA7B10D1BC0696B80398199B849DF9AC91407FB5F
+ 73387CDABF0D70570167E28C95375DAD3176051C9167F05FC9E5A4EB64B4EF85
+ 147E75C179F5DE1BEC54898014040D34EDAB78408FF3DF179539CD1D78DB1961
+ 9F64FDC62623B45D9451F0E0E84C82E38FEA4A2FB7B1AC764C2BB7A54E7F2F81
+ 3D5320D9FE17A8F69C8F9BE8E018CF1B057838C5DE06A986709523855F2F486D
+ 6DB186B70AD3EAEA14C66229AA16D95E42868888C7EF9E0ECA8EF45E75242FF6
+ CCA1BD1BA9D5F80D85FE2CA3103A165FEC935F15FB973D0C07D7AB46D04B3B3A
+ 07C7262821170D3747C7D46520836B7155C3FAAE5340E5675B5F83385181CCDF
+ 24D4D21482C7F1F467B8EB1B4642ED35B95517FA92598C12004FE4FF06CF0D25
+ DA2B1B6EE234C2D8217FEE5C1663BF21829737DC9BA434032887C50FCAD17DCA
+ 0AE003EF0B5AA2C17397E926E5EA036E833E970FFF7F51CC837A4C619D862FB3
+ 8E3EBB1BB3C2D10106371C6BC41E9C18B79E4AC5CD0B52B9D53E0C7D40A5BF50
+ 32731277AE4E45DE44B46B29D94F0049FC2B43B6AFD37A00BCB0F0857B152B9B
+ 627CCCEF26AAFB744C7593DAD888D5546C90CECEA237A180FF6CBA55B7262327
+ 06A09F91309FEC800F739A463BB27C8B5B53CBC5EA727F1EF96B20EE3BE16DA4
+ DE29050F6BA2315A89E0E0C4B4B3E84B632F0FBD675741F5B81CAA27CF56B1F6
+ A46BD3B3C5BE9656ED29426E9A9E27FDA19097AEAF350FB6C501DD8EA6593354
+ C26DD0E9FBF40F7729B4D990A2098097061EAFB302A9C8369FCF2316FAC3D0C4
+ 403302E1522AB906CB1229AECFECAD3958D52B545662457A2538EF2939D54370
+ 4FCAE96D9BB0095E224D32984177F463AE286D121931007D9E1C8D74D14B8F06
+ 94C1F233E02CC2AAB30679FF1189999755D63CFC1C805A290B0C9C43CEF69BD5
+ 5E243023168DF0BADDCD239FFD0BD3EB3BDDB30FB44C6C8AA0C0F08B443B0798
+ FFEDB96FC5C854D9D5E319F16EC7BE250924E445E1E48110E835EFA645D57AEE
+ 009DB8A4C4389FB7F01A43985E00805353D8FFEF94336571A4A69C6A0097C390
+ AFF3A06883A10E1C93C646A1DF0C34C7004B346F8BD896A9E5640E7355A419BB
+ 55377A1765037736E96EE60C71D57C0D3056B524B120F7805D3089F15DE05F05
+ 21B3DD9A89386F0508B6A8095BBC12D5C5B8FC444BF5116E67D349C6ACE3F519
+ A2DFACA1DE2267BC18470EA1547868D9A70CFA10E961C75329202E926BDA8499
+ D3DBD210BE966DB2F86248E2C3CECDF20C37F6FD88D64799523588FF7FF76B87
+ ECB9C772E398AC9C0C04EF74C2CAE5AB760F08568425DD92CE1C4BAD9A723061
+ 494087E8DCFE0EA810B926A5C5FA512206549F5E599314D65935AD9BF7F53918
+ 07A791997071E956E28D69084CEE5B558E6167E14512545705A3EBBFC0957BBA
+ 62C67EEBDB80985E901675BFD4D1953E219FBAEB79031D9E87755D7CBC196241
+ 6358467D9B48642FC93E24806D0BB951D51778D4E26303F1E9A506DFD157D782
+ 3FE9D0CBEE35829440E8FF87BA59CCD16FEC2DF14FB2BC58E175B7A84205407C
+ 28613933FA59E05B449880E0403E01BDD01000C469F2CD1E9653F50D71D070A1
+ 4543FB8CB6250736F31AEBFEE2502EE1FEFDE7812F577C48F475541221B40ED2
+ 3D40BBFE2E2DD70AFA8DB8ACF83356C6875F91C324CE1BF91F01924CD53642B2
+ D4310AC0BA83EB187959E8FF66C24D3E2DA68370457AAD210A49CD91A5C0382F
+ F6DA6E35A33EDE7C07CF260630BEF7BA09BF7F171DFBC8986A4953C1211AEFD7
+ 0B3F1EBF03CEE33E8AEBDBF76AA0B80C2D4F5713C8EB1CCB097736FE5A71F256
+ A4572C27598008F1BB6406DD45ED4C48F7E639EC090E1B28F6AF9E7E17877480
+ 61B4602C8FF8DD90DF6E4EA0311B4C3412B06F8518169B835A63D3398CD82C72
+ 2003E296724D88462CCE301DDAD85F263AF77734B3BC93484AC173F03830062E
+ 31B09C1F22FA309EFF195F3A4EDAFB260286B752C5A5AE56B969290BED8876A5
+ A27251F9EEBB44754B85A625A9B66AC9003AA12FFD79DC1BD3085B943C6DD470
+ A450C0F3DFF4471B174F26140AA29D53A2FC8C4757C11D62B0C3232885925FFE
+ CAC16E2C00B60A66FDE7F4917985E32417F79F60D6CCFA2CE4F7AB18C93C17AB
+ 848429854E499520B11CA7AC9A420E09E0552564D6F287AAD4206D48FC994590
+ DCB39D9792EAC201CF21DA6463BC525F525CAD68572FB7E3B389D79E8CDDEE14
+ 5AEE6DF4E93667997A5397A162F9BB01F4261C235AA85B0A200A3C0A8885BFBB
+ 0AFD6157BB635A6106B1E27A5EB950D1491E4F4164030933F20E79B9F229E56E
+ 0331F7AF9C25F0A2B510AB5CC360B8B15298EDD69AEAF7419F6A4781B0D2BC63
+ 1ADB3A779D0F15F613193C638187660ED5E9BEF4F1217F1BD3FEB44C613BCC4B
+ A2F992F54F00EC0AE7F39C103DF175AA7B506406C2C58160D8E841B608B8E9EB
+ 4BDFBEAEA8C94945199702C7458017B3EA3F13F04315EB376600D791B15F25E7
+ FE6A52F7768EAA149690CAAC149DB82688777F684F8C5CE6DD402964501C3D5A
+ F39960AF5D747777F4B9455005D9483C216068C5BE22C288E6EF036F372D0B1B
+ 96654373AD9A7109B79E306D0FC76EC8A896F2050E9DFECAABAA7E5B5253DBC8
+ 5188A29797E2513E29BF0B27692224953747C8D62A61DF63A0A31FE3F95441EF
+ 4D1C6489F1AFB39EFA97F955525B854B064261E8C777784ECC0F8B631F8F3D8E
+ DBEEA38A659B11D67DBCA6593CDE94F22CE5F8A2F90C9E2007CB246336549573
+ EAB4F2B4BB7318C5EC4E47E88BEB7E21520C9CBCDEC197B37B5F98C7AF9AFA8A
+ 485212088C5E984DCE2BEFE33E5D9EFA50711A7C489B55D9871B81C3AAEBBD4A
+ 822609644B5333ECF2F5F7B11350E566D9B4A9563A50936FC0847CE4560C9E2A
+ 9D228D8713FF37D20F89DC0F339A17F083946D07C878F45657A3FE10382B02BE
+ ABD0BAF50D1B2237BD4D09ADA11FF0BE6D5294384A07F683068E37250BDF6F7E
+ CC01602FC467037E20FB1652318D1356A62208B2FAC0D80283341DF273038448
+ CA4EA93DCB4A513EF48DC8B9B2ED28CA08F2B77E704770E39541B3D8813943A5
+ C38BDCFBB3D0F3C40C5A92AE9B818C73F14D169430A9ED5559CA1A101E1E58F2
+ AB107AFDADAF3083E0B482D15F2433552A53238DC36C31460481D82F23B4EEA9
+ F001D6B03346C335107DD9975A0D599788DBA3244BBC2D33EEC2055F527948BC
+ A2BF8B41B66DD718E8AA22FECC227E35875F11AB3A862B72562B2D6D831B8F04
+ 9FE90EF81D4FD7974FC7AD65BAD156C3780529F36773CC819F3DEDAAEDDC830D
+ EF19EC17D687AC2305CF7C091218C6C66026C807D013CA2CA8381E026D371DAE
+ 3746BA0564D048FD6E0CB7A37C2FD57071B5064A10132E78789902206C99C068
+ 49DFC84FFD5085CC7AD55B093AA054464F5FFEB3E3C3DE0C0200D9C107D68F23
+ C348A943680AFE096EDD25BEC0856692D0BF1193C11F467DC2369A5C80A3AC54
+ 4C132940F7EB7C184F05BD821352CDAD2B428B3E536EFD6FBEFFA46B5CF27F80
+ 9BEE78EE5A471485A31B5DC500727E55A6DA3A095C92981DAC1F5A233A688842
+ 8387983E708A23D6E0105C6CE9F705E87C4E9C0A4B93FE2CB7A82F8A7DF1ECF6
+ BB77CEE5C2754154344605875216647BD8DF9D6D2EBBE9FD1AF21B43DCD4B846
+ 19319AAB845FC7A5F4B27725DEFE4A19E644909764837D592492158606E542CE
+ 1853A925CC38A526AA9EC7E3BD3332A0152FD79A58DC1EDB9D1E54276401FCA5
+ E9A6E94DCC90B53C9DA305526D62143F4863867EBC5EC3C519F782599E2B5E1C
+ 544CAAAE5CB8527B2D8F5A25920D61295149B07E0C176455FF7350C323B075BE
+ 1197E2E8B082DEABCCB92412C0518E35A0794EAAA80C7F9FB146AC2AE2233B11
+ BD67BA5425A084018DA987240DC74E94EAEB78D5BAAC8F253F66C5254B01FE64
+ 199AA69B21F621630DD4AB63C5B08CBA9847E09A248F7D197853D5E489EBEB06
+ 8077B8FD88DED2AE5A32C3D816A04E2FCD1943CCED0B0AA8CA011C6E76216480
+ 146D2E3CC55ACC32B175CA1491FABCA1E66454E2464C64BA4CB386A8387A3511
+ 3EBB714C367EBD4D2C10AFDB2A093FA75D331DA9CE631E4C121C5EE2A539D62D
+ E9FBD1EC8433BD6CE7CBCB8C6965B8003E11922C4859183903BBC146026E4518
+ 2EC39A7F16B195DEA734CDEF8BAE8BE4D745D944CE102E25593ED1CCDD893E0F
+ C7B2554387005B0E820EF7388AE08F84F679716C68F705EAC17F2FDA9F03F69A
+ 1394AFB3F21A058B99F2483996BA7E4666EFA5FDF38525D0DA9AA579806C0FFC
+ A3AF18599C3BDF030390CEC17D95211E7BF3DFF66CA974E8072E18404752180B
+ 193018591467462F0CD38E9496A3DEFE0B57465403D5F7BFDCCAACE20C835A32
+ 75D6C3BAFB6B6205528876017ED68312BB9F2A248E6F1D026AF839CBBC683FD0
+ F58DFC977CF12680A0A8F59E98748A9C83875CDFC66D43ECAE5AFEFF065AC3BF
+ B2E08C9567D5C7F0590E561A7B5152F0918305C3056B6F7FFE1FBFCD2A04498F
+ EDE168393F5B7BD93740666824C012E4E8E724010C61E75307B12B5B43D0BE1D
+ DA0DBE5DE6F6CC81142D67EB0E311D325CD62FF8E4FED7B7F227715DE1B6517D
+ FA021E9994F97ADF6BC54C8F829ABE4742DA6D268C92807B921A7DB9CCA8BE10
+ 78464F032C9932A99DD7B113F35AFFC6A4067E892FE84FA397842390B2034CFF
+ CB2920AE499F75C58B56A8510371692D873AF3807AD794D72C1116F7D7A13A7D
+ D7860D663799AD5825C6173C99105FEAD68D175EB84A2E1D52EB888921B7EECA
+ F576B6E0897FCE44C6EC0B689E86763B603F1CF741B78AA386B1173EB60EB2C8
+ B109FA30AB8F043E9A6F3BAB21054DA7E5F763DE711F4031A082DA3B08E79AC1
+ 270C364F4C09C17E9AE70C2AACDF020835261B5DC3C83B59B240118F99562F20
+ 155B00C0D089E6848ED7205B88767B7C0E139A20215475EA37BA3C5F5358FCC8
+ E489FE1BAC324A08E3891B12BEFAAF723BC5B13AD28854CBA619AAEBE66FA5AD
+ 6130E4D66770A336B69B1E8E0E6E4458EBC1CC599C18B7D75614023D3B6A58A4
+ 907759FA0817A354971F86F392D0370C6A6A218801AD0053535F4FA35EC190E2
+ 0610CF5E35D3E2BE2BFFD8AD9957867EA0599B5932BE89158B7A54F95D6285C3
+ D2EA7554A16625D719041A2161CA207BC99777C46F17A875C0D23FE75FD05034
+ CB1F0FECC6319595C61BE949DDDE3B5C549CF999D5B364AE867A69AB88D74527
+ DAE8E5FF62BD2E83B9BE54213E2733ACBAC3DA0F6E86043D5B85F3797F096556
+ 64ADBB353C26D12D1E9DA7602221445FA6E6E0489D68BA49A2E2F1FB4C4E0AE0
+ 2751E2696E6A900C5A53A85CE24A362F8B3AB8ABD388B1D18A809C5CD3DD9728
+ 42F26B552CDF1EC0B7D41A6F4DBE3A4013EC013B85EF43D7A5716677F17A1873
+ 5CD25196863614C5390A83785511E6E3FECCC6DBA9BABC8589CB1F03B44918A8
+ 88A5F86562FF0280A41EE534D5308FB6888E113FE6466DC737362C8AD8541728
+ 140A4125FE4993530B4BF7E1DED22C18BDFB83FCA456A01FAA79E8277CE304A0
+ 591BFF84D53A802EB46C187D8371966B78A7BA7918633C26EF06FBB939B8B1F1
+ AD8585765566CD9B9C845CCE63F113D1A76324639C8C09DFC27C43DAA084165E
+ A63EEAA6FCEEC98937529C730F2C51E3E1D03BCA6D5233E9BAB7B79132A4EF50
+ 7ED5A618418C829BF4FD83EBE78140E394CB9C78596FE80E1386B7FFBE8AED43
+ 54DF76C4BC45E64CB5CC9E90169853B0FC8B979A97B4D357BFECD90B61562213
+ 133A876E6645B4B9FA8FD592719BFA9921475C1C552263A7F3AC0C81D6FFED5C
+ F4C513AC4E61783C81D5B1C17B878281746A0C92C877B193A67BDAF34409E9F5
+ 57FCC55C1490939D9BEE07158CBAA67526E00981FC312D57460443DDC2FC4117
+ 0A0B5A03C5D2380C9CAF17683D6C31174E7ED28A702ECC75F9D223E338CBA5E7
+ 8459B891E5B059D9BA06EB6042513D05505F8A81170CC870389305B2A864463B
+ 01AAFD1F466EBB685937E7C0AB935510C07D401738F1C4C44BC1D875D168FC21
+ B814699498F95C7C08DEFEBB73814EBCA1EE8DD9401486B4B4DFDDEC5AE3D000
+ 4B0E4FFC01D7F0ED874708F31066D4F3F46FF8637664D256D888B1C708CD27C1
+ 8888427201D59028AB6490B1E035D59DE25E1B59B96B7DD4570BA7F7E2CD37D8
+ C7AE3C51D0FC84A147C821BCE147053578ACA41C9873212344709DF2D4CB97F8
+ D1C598DFB2950CCC6A008C1022E32C491E18C977A277CA6118ECB8698BFBED2A
+ 73EDE1588D600AC2F583EFC1B5EE1BAE0E9EF74306A6B7E2DB59572A4429EB60
+ 22CEAE58FEBEADE1E6450E913E9662FEFB439BED85D6B764D34333DF1DD838FB
+ 9207D5C7D20F3B676D839DC41A8A937CAAC94BFD3D1B7C4EE0F6BE77FB0FBF32
+ 204C6698034756071D626D931CFC587C60CD4C8DC961556BBA68BD164D7D0B07
+ 19A24FC051CE644A7F0EF863BF85EB3F7FC2D0FBDB38AE4F276D5DCB818DACC5
+ 15ABA3B601E98B990F5972CE49DAB30DB2AB01469AC12B37FA2CC625CDEECFEB
+ E090948D9390E0EB09FECD350F4860E687A102FBEAACD86FE68905C240627934
+ 7A8FE8B2537A4A8FD18AAE05929644D1C14E53F9CBBAA505823D5AFBE7A876A0
+ 803B5547F59FD5E23514F3CC9BACB56A2522438032929DBA481CDA1CC876A7D8
+ FED4DF9285407F909F9427AE35EA5E1CCA17D12D47DAE264143FCB2D76A259B8
+ B7D976CA847D5BC36FEAC76CE9E7BB836E7595D6A5EDC2DF9B1C615B31B2E24B
+ 8186BA797EB0163905634F5FF389F2B05000DFD2E8EBA41D9B9579B07B3003D7
+ 511A550BDCAB16CCCC906B922AD37D6F75D21CBFBD76D113CC66A85B0A960EBC
+ E53D159E07FF13148526CCC84EBFAADC1B06CC3617BED81EF82B49B74B5FB6AF
+ DB60925F46749DC1EB09473BA6AAEDEC4385883704EED40B0D127BCD3C0681C9
+ 50E4281B8B4184D3E7274B6CA8CEC7D6E60D63EAC65F633B815C19C59A068CF5
+ 4A868533CED85D7708ED36B465054C9567D111B8D94A4D120427526A0651850D
+ 14EDE9BBAB7BE26900BC4FBDFB591977EF9AAEEDC0935E28509392EFE3B76E38
+ CE69D21C4221DF871E912798BC25F00F114837836BDBB6D0CBC9415A0623D7C7
+ FDC8314B9A8EBADF3381AA6D19380814E93FB5B8D65A8BE80D7B61E881581309
+ 04C3B83839347775FB4B15E5588E21FEDCBB8990AE07AD18FE1E8F28B8C1B8FF
+ 0BB3040E4B2E66EFB4A2A8FF18D16B8E6DB2C3BCC4E22A0BAD8A6D96CA1F96FF
+ 5E520B04928461FF0DDC6DB3EB35D51B98665528BD7CFF66EA6B44A31DB050F9
+ D5785D7BD6DE9EF8EA3A7ACB3FCF4EF299323CB9F606C3C4838609206B12C20F
+ 94A2A2552204326752BC57EF9F049C8EE4510EFB2EB8321CC9019ACC50ECF9DB
+ 6419C1C3832824692A49994AEB7BB433A07E228E39668B49DC3268B9C1DD5897
+ 95B9A5DFA3A0BBB2D1184D40B2EA9EF01FA265CBA07926435A5688C8A4BF40A7
+ AD41087441B8A82E297B6DF4CE944E3CE749C01B1C5E1FB12AC57B8E6A42CA9E
+ 169DE13E085A35C58CA9AE4763108C9FF32713D0343442D979B8D388297CB85A
+ 3E1345CA90B597774BBFA45509A1D07174556827F5E47C02E9242953FD49C3AB
+ 6118F1B4080400B65885BFE41A036D03BF3CCD0E9AC3F7A70688C4A589871D6F
+ DD520D7A468A7F0121DE9BB92C183638C427282CAE64E4B129F47ABB92E4688F
+ 42672F7AA273FF37E4325924BF3365E30F262891FBE1644237D30050E210A65E
+ 66F8BEBE700AB3FF67F5A04E0651062397898BD14429A2C9BCE5A127B8F2D6F4
+ CCEAD1285FC56B0D1F47B6E082D08A9DBA0BC4FB404EB72768252C66F75E2B33
+ 1CA51BFA144A35D2F6CF7C085FE217D036D2ADEAE03C09F60A16F913265C7068
+ BAAD6FBDD56063AE23AB03F5F0BBFE7F7E3A1A73E35AC5B05BC012241701C847
+ 0FEFB7001DA36393DA87694DAA7ADB348F32AEDB1FE3A25D9A299295BC3B0F66
+ ED5E37505527B179CA5052DF22544D3F56E89D4C329B8A7D63BDC0DB30728D9F
+ 956AF04429C24BBD96D948F6E0C22AF3980F2AFFAD52BC052DC31E9B1C7F2B11
+ DF8011ABBCFB82F26A0DE6FB6C068FBD8BB8391FA1885289C512AC92C8F84CCF
+ E85B23ABF35266ECC18F69F13DA82A04E83A6D063F3700C982F04497A7DFA6E5
+ A0998C13630FC1358EAFA81F90A91C2D4B14391C9892AFC0B3DFA6D8C392B8D6
+ A8490A845003069A6372ADCB013793AE6A9DEF4440E28C88FDCC3B7A8013954D
+ 74B07F3374EEFE4C7AE3CF4A07EC9E2BFA1E136EA8FEBBC297E86A4BAA5CCE69
+ 38A5994955999AC6A171EB9AA355B37F2754F9E9E911FCCE3CE93DB0AD719018
+ 5C0162507374FBBBB58569E08317FBB86FEA59C5A289117ACFACF8C465EC60F1
+ CF7A36AAAAE368B2DAC13395EED48B74F6BFE51D4E936FEB664D1BA6EA06EB6C
+ F80B8D470040DF844C1DD582ADA84A6B9B4CE97281ADAFB336AACA40FE750166
+ D749E635D1B9C9477B97CABEEED0A41FC113D6CBD1F0CA8376AAFC2B0EA7218B
+ E039B66F7C75A22F34C687D6B2BA3BE09291782BB506BC7C6921A6C5798506B1
+ 682B3B3F27A6D6C5756EBE2E628F05583FE4F0302EB2C42E25C408D525B12CC4
+ 4465FA0CE523F8816A59C224B78E48B84A03AEFE16FD89A8120026C0A82F544D
+ B43B293DF967B48E49977CC44A59130052C128CA5CB83B94192832792F8ADA8D
+ 1580CB84F5E14CB4AD6BDA11E670FF6675EAC338670CB95DC37776F4596C1FD4
+ 3B1D5BBFB6A6DD25E6E199069C1EE0A8ECCF8D8407FABE65121AB505BFF33379
+ ABD0BB84081C57D24B81A90D63830A398A441B0A53009E1830670591DB065DC4
+ 87D7324A5E15E6501FE28AE3860C899678C625D565D8E08407C14ED4CE545E21
+ 1422C926DDCC42739E97072E042C79515699A017F9F2FE243C8A6C00036AEDC8
+ 5E5DE474643BAEDCB3E7F0CC1FEEE7AFB54BE6AE3FF09B6535F43896C49F7605
+ 896B2C07A041B648E85C11AE5C34FFB18486B932261567F4AA7383046E1E1D82
+ E9DCF5976013AA21ABEDF1A15FD456662B05F5A1577D4493A7DF05F345BE643A
+ 3FC686FC81D8BDA0DBC0A47E4DC28F63492F240512EB5ABE1E6A008D819A01F0
+ 705599F5BC126CFE633902DD38F4731FC7979B17920061DE80322B6BD5DE33C2
+ FA7791B25A4A217061D1AE82DE3ED2D3AEDE32AEA047E61BC98EDAA83F114CF5
+ 52BC102A9B2D1A0E3C23EA5AE8B33CA3FB934492F743910EA3BFCAFB86A426C7
+ FCCF9789BB484219FC446DF666888CA6A39CCC3C76C2E86ABACC636F2A93A544
+ EA0F9180FA8D61DAA0EE40A6E406D09CBB70C53570B2F6F3C4CD64698D7CB7BF
+ BC3EF0CED948BF6D40A5BCA3627295A4938A06AA6A6C4B4826B088C6AFE9813B
+ 908288C3981A180C01AA4BB4E4B53BEBFC9D1EADDB15A7F22D7CEFFE39834139
+ 0E97C6481D8C5D8E1EE151485EB2C8A093DA048AFC4BA0F50277FC4754FC80F4
+ C242A78ED01B84EFC96FE66DB74F549844D734BA2C7EBDE04FE5A2C64D21B9AC
+ F5361E7881AC69326C7122772586D9383F64A72D29DC3356115A8CEC7F5BDADA
+ CB9B22B86CAAC855741C5ECFB8E3BEB6F0670435179B555B79A92B4547F1BBB4
+ E3B69DAC252258B728EF0A8A9B39BEE68BEE485812F04935BCFDECB1B909944E
+ 8CCE204328C8200A370FB2F359FC6B9D1F0D06DC2A8F14AD45EC3762DF2E2EDD
+ F63BEC66F5869703ED6936478D96EC9E0269DE45B8F2E99F87860F89008502D8
+ 203335B09578E54B53A21E740E6542D8D1AB249C604162092DE5545A6EF88A84
+ 4C428BA5A6A139A646A30F5F7DCB31C775BC887DE2E457FD588556865A4FE3C0
+ 61EE5249753F78CAEE9C1340829A8AF9D34907E1C4C8D2BE7FC725AFC8B42C6A
+ 657EB06225F79FB20039446213A69C1242BF1A7B35AFE0C35DD40B3E4AD862DB
+ F3ACDD0B9AF0A59C5143645BC27377655173BE40D2C7B014213A42B474848AC8
+ C23AF3BD691E55950419BA59DBAF6BF29FC036F3556394DBD7BDB696A2454286
+ D02F7B555226B1DC70B7D72FD879520543ED150191D9798F2CBA452502F31956
+ C7AA753BF21599B74DD82D624B88D84DBCC8A7D3F91A813B5076000A7DF5D3E5
+ EB77A6E06FAE868AA4280B1B1A0C4B3203BD0DF7FD88C1664AB641994BE45876
+ 47E660E536A31ACFFF09B34AE9273C9B293F419AEEEF11A62DB7AFD4F7D71ED1
+ A9884970C32574AFE26C7BA8F3070ADACF283F608F474630FE014EBFA033F887
+ DA3F6C89609A8F7409C6B680D527D685701F60D976BF862323811D1A4CF161F7
+ 0E6DE1413D5F545EC22423D7EA52499DF32C6DF48742F6906C92D463E17C60FA
+ 01D327A42623B9F34A434784937C0ADD9FBCAFC8FB3954FA9288C3A76F93A252
+ 45546611583103029C260D91FB1A2FE998564377BFA89798AE7FC04FDF97DAA8
+ B93D2BE4943966F7DE345ABB559B1B2A35887551F7E8CBEB707EC5A754EA47C5
+ 5AD10776296CA778A8E32718AE589D8F5CE647C641D47797E30F450E4F7CB5AB
+ A259E85F35C3F50232AE4C017AC89465CCEABFA3655EAE05DFFA5D4EDEA28907
+ BB617204E046B46D4762FD952AAD26BDEB6A5B093D1276EC35C0F4FD1B251375
+ 8640DAC68FEA8131328E050152CA28E48DB4AB2BB7404AF535CC015123ABC74E
+ EFD4D396CDDB63E8DDEA4C85CC4D64C6E2F4097713028219209354ECF772DA64
+ 228FAA15D348527D1347B4E3DDF9C339D52AF736B4CAA3EE11A4A3C935CA480C
+ 707A4B0633292DB5DECEFE6C522D3D22C583F035C2E762E9D7FF55EFDF138CD0
+ C7FD770A2C0EA24B7193EAD64304B1693F01E67FD3C7594BE11253103C989C5E
+ BC7CE52CB42BB459D1E537041AC19B0C39503A86D0E3599BFB2646288BCF0928
+ B91C5C1879A6C0D29CBCAF3A3D669A1CC3AA067FB85423EE79269A7CE602F051
+ D65A23F0C82E353A749893E14434826AC4BCE854E139B01EA8D5260D591B6C03
+ 7898C63C84B8349309A8D17D446631838E19C8611F094B8B0C0DEF663D268109
+ F1358C2F96129308C61323396DBA9E6C4920BC83592D2199A8BAA37B03A8A3B5
+ FA7C59C28A1967B81C25694D8CB0A659B6FBCEC8CA9780C0958368418D13F184
+ 70D219D5A3DA306C32009DC98923F9E01B56A8112433F8A730D828D13F426D56
+ 72506705F2619A2AAE07B32845B3573257DFB7B79773BDAACCF59B7F20AC78A2
+ E7B03D8D673835B00402B47DD2235C64320D331EA630C90E0DC7EDE0C8698C8C
+ 98C66BFC927B5802242CD4F09FB02FC564841EE3932855404E7E935AD5F17F97
+ 3BD3D41066044977CB1C20274229DB7CF80E3FA1B6E108A90063D221461FFD57
+ 5B3B3BA5B512594785FDE003D20009122B1E64FE52B3F6A28D48DE4843416237
+ 5A6AB7C5F7AC83E96C4AC98F2950A92C2B544B9459768DE5E79E1E448D55DD73
+ 34D66F2F5BEC07AD03A6EDA160B841D6C0F358B1917181762722F0C23D3DB4F4
+ EA1BB3499F2054ECFE42073A97CA33EBF46CF5AF4DFCD7AB7B73531D24EADC3C
+ 1A63052219CB6026947A802846DEA171B0416EF0267093F7F3DB188874D5D4CB
+ 377906B8098AFD89153AA32EE7121DDBED552CA3A7193D981F7C64767B4E1048
+ C8AE7DBED93217A1DBDEF8389B05DC846D75ACE44D775FBDC55B293DDC5266AF
+ 052038F71F7B6493ED3651AE935CFFA42A64059C268C39E57BB3B76882440E3E
+ 6AF1C73BF041697F1BBE3FA8DB86F84D17AC1F262520535B0224496A169678AE
+ 1F96994B837A31AA08201AB23A179ECB2E2501CCAA90F4FC70ED2CFDADC4FF98
+ 1DE1FA214EF976148CE2AF35792AE989B324BBAB0CE3F4FB4E3AD64453BFBE37
+ 8FEFCCE2AB1348A0813D6FC0FDC59D3C0F9DA242BAC25427A0E3538BDD963851
+ 5EE3C7A036D35DFAA4EBE8B69BA41C4A7CBDEA38C80C99C6941129AF701DE217
+ E71C9DD44B755A5C5A870B5F3BC627DE88BC0930CC43FEE06F5B8ED94BF96999
+ 1C738A1B54EB0C8956C094CF97C06BBB9D32A85562D418F2517688CA195B97A4
+ 3158E147041AA0B82260B19FBC56F7A826B1383264D5A7BDF4EA53D73CFEBE15
+ F3265E68C5C8CD1CA201FB575D26C97D49A8BF97555D77036B8C92B0425AF92F
+ 78DEE4DBC6B8FC443CF11236BC803BF44818C6BF0834E7B8EC20B2A3E43F8799
+ 9CBED36088D3A0CC5E1D5E7472F071C8B6E02864E17704DEF7115710C4CD8A84
+ 583F80AAC6E057399DC64C260E7DE9A051EB7849B1F8EB376AD648C9EBA4553F
+ 108FEA93D0ADC85D0DF63F961833C9A611FE511EDEABC7B454A45F08D246D675
+ B8A7626F5DDD3EFBB2409119A1FEC085A9A174B162144E4A2AB63E0303F84DBB
+ 71FFCC882C3F077A21B77ACBF1EFACDB226D658DE6D50AFBD041940D4C0F4360
+ B325A35FD35D47A8E0F821A253E9E54A30D78B457811E4FFFB32E61FBEAE8B0F
+ CEA93FBF11E3AD90B01336F1C0FD86A0716F76A10C05D190465802799CF57370
+ 68C8892DA1685A33BECCE5B82ADCF13466310B1BD0638180B805CDF488EAB185
+ B427A5351F77DCE78B3A89010FB846DFB6315B00185335459C1D9578457F8931
+ 21F3C90914A9C3A5A81F4EC0766467D5AD705AD9F892A3A35DEC5BBC768BD2F7
+ D2AC7FEB16D0BF28F5B50887A75097C01869B098DB10279F6A30B858B8966D9A
+ 1316205BDEE19988299085488F02113EB16F5C92BB53A43C595CE7D79F577019
+ A2E6673D6C954535E3082E2C340560092CA798E6BEB039237977FC1B373CE37F
+ FBE2A745F31A88BDBC39AE7E127DC24EF6A7F10FD1BE7D5DE98BCB27D5B7D750
+ 0575921F2431C812C55555329D40979F8AEE390D993706880969A05D3C7CE281
+ D398E688E709F4E79899C5D29218EBB70ED0762A50E3D5DE9312DCA582B983A5
+ 3EC018A68348B4D80138D48C6C0A2180AA5BEADD221667F22C15B50A0ED9084D
+ 1FDA8D664A80237A02CD95679D801196C26F40C6E774BBEB3478D17B225DD294
+ E7E2077D4AA249A72C487DDCD2557BF04BEEB146D08823A2C60FD1FD6D62890B
+ B71E701BA187E77B68461B7101FA2473F084FB18A66391CE9C57997E8BC8BB43
+ 778AAEB595073EF7CAEA5776F125D1ACD2A85D23EFC09D5220493925D3F8E137
+ 92FF2749455984FB717BEAFB01F7D47C09DF06BDE7725EE7E73B1DDB1AA9DC8B
+ 2B5EAA574B7C0836B962530462014B011148C46954793FA0666873D678F92893
+ EE48F02261EFFC6B32A35813CF9E07AA42932386B1AC7B8FBBC7D8F55951B76F
+ 3446DADE6FA80C4D6D4BF8E39D16ACA390B93A989A5BC7CE24922B31718D473F
+ 08B6E198B7CAB1E701FD8C33A5EC55BDA065093E2B3CA67294F76947261097F5
+ DBE24D00BA409FD3AE294B6E43BF6FB4E2EAA2455BF23829DC5F34AFD27D9653
+ 4774E3F7BE1A65A73811BECC88096CDC57459559FBBFE9DCBCB98854555DE680
+ C8EE3ADA0862501CE30859B60C53E48FCF96B676E613ACC476C83146EFB5CC7C
+ 8B7DC5B1E0C1FD96E470D7EE88897F5AF93D8224A2DD60C04104019EF5FC5E6E
+ 03348E803B1FA6BDBC976830D3575C64129ED23594181C52054B275CBC7536F6
+ 82FF1BC58BA90257769E1C5FC8EE2D2771B9BC1138B6C4DAE4A75C7AD2926177
+ 39A08BA53DC515C681727BF7BE12C28D967CD32E03BDBBA4F44A8D6E0DCD8A0D
+ 8F97B99B211CB1E0E97D3C57055F0024B6577A84C9662284435835D1CCCA7AF4
+ E824394FB95BB209CF73165528C937BC2374CCCC4151679CFABEB49B67D33297
+ C40C16E101EB3F85C48015327A2C6EA37098DA88B1DD9FF83A243C25C8EDE8A2
+ 55A8BDC4A0FE26B2050FAE078623076576725AD79DE53FC7E193CD4CC25F572C
+ 677D8545CFA1CE2A45A6AC7D9D84D29A1D4D36F3A3EDEF29FE3D1AF0AB9B08D3
+ 1832FC91864A2622F671E24EB6D1BCEC167D526FCB9415B11C02A0ED53546203
+ C0B91F2194B65AD7EC42286CB55E629C2B4325EC3E1B03B933746E87C6AAA8D2
+ A236EBB1E3DEA4D0C7916512C3FD85B66A15E7A5007D41A38ADADDA005045811
+ EB6C5F6718542A3F07F58B9181CF588FD7519A97A4F82A7CCACDC651E0E384C1
+ 2C482E8D102090B8B6F08489760DC16D255EFCD4021E9D4469F1ABF4E22777F8
+ 6A84AFC1BB5BE419FAADBB09B7199DE8A7B6CBD847C546B4C12F09B5DEC76ABF
+ 66DFBEE8BCBF06DF426A51CDE6B3D1ACCFF21AA74F86266D68D2118B7BE6AF82
+ F0B4F34A0DDA2C24304CFEA8B8625D2EDC88A1443068246094B5ABCBD920A555
+ AE84932E5890D279A1620816DF93F90861AD7BAB512894E79F448AE257240D48
+ 4073A989F3E7A5E47000BAB9D110B729718071633598DEE9CB5626A16D86B01B
+ 69DC1F0FC65803625641302EA465474CD6A8BD3BFFBE8F5DF1E6F621772B8821
+ 9527A580D851F928ACC68611FAF07537CDAEE5C4B873228B3F7FF9A5D5B27C9C
+ 3242FFF483B22F0E9A91B28EF510D6C43B44368B045F82AF51AC5B4DEDFFD2CF
+ 83D11845F9BE01D8D674604F4817C052D24AC144ADE73DE38EFE4CE18B2523E8
+ AEA44A9A67664670759E7309D151712EBEEF34B8E6AD0D3FBBC1E3A123250C0B
+ 3432FD3286FD73271BF9D06697DF83D47F668EDED8BCF7ABB75F8C5BB1A7A952
+ 03A6F7C9CB28E16446101F6821303DE30464D487CF910F7AD6E4F069066CC5D5
+ 52E92EC71778BEE3277FB06C276603881863B6A45917BF0C3D01CCDEE979271D
+ 4BC5DCDE1ED77B6CFD10B955CA323A2A0DA653DC555611BE70A2CF957B8A6B71
+ D62811E72BA36E62B662B7F1AFFDD095571EC219BF958F15090E04CD3BA3B363
+ B2AD03F96BAFE50B08149ED160C93D4BB4ABC4D6CBCC2DB3DBF5F722AFB0A4E0
+ B0F848D84BF3AAABEBBEA242F55289DAE74B737BF44EC36FC0DB048AEE16340F
+ 3EF5E4036F97FED3C3AB6570C35F29F02543C698E435940C1A875B2DA1CACC8E
+ BC7E129A064B9C635D3CB53F4D58F1D5F45730711CA674CFEE78C81C4C678361
+ 38466390D68D95790FE5B649B9DCE81E6FFB0DD98572C0307F3B8B1BC44E5421
+ 1C86951AF399BC548D9DACE3C73BED3611B329FABCA71A7E1144C8AA7DF4A245
+ E12F91B59AD3C804DF16BB2D3C381D74CADBF95729558D67F515F115B5960B00
+ 326054BAD2A2601692EE035D205B0CC090589DA989B05EC6F7A7593F5F57C104
+ 208B9915CA57FE4B322FF8FDD9A5968DE6D47D19344018509B099FD5D167BE4E
+ A7BDFD7C4E6BF62683EB1AA0739ECBE98D53A6EA6170223866672A355360D2FB
+ 506CA0E86AD5670F74E141DCBF5086970B5AE41839929E6BA0D768C3D1534F94
+ E8E88A677542AF25504C0B22F12CBD7B4BF7590182BE110DEFAF524F3ACE5546
+ 1258FB664ADF938F6469AD3DB449E826999382D34E0DEC20D2AF8D9D421027A2
+ 73AFFDAA6A0BB620CD609785AF797646B1FEA7E947760D461DD599448B340F75
+ 4851DA69F07334D933E284C0E283AA0CFC7DDC906A889B52B882BA4B1AE46428
+ 3A58A803F2D435C00EC899B9ED8E506ABC4EE38B17BB8CF5D9814331F77F294F
+ ABCD5A1561CA9BF448691FBD3D2807C4E083B7B7A8AD21CEBB234B9305B90E64
+ FE425F97D3BC3194D1B65AC24E191869C583FE57EC79E1592D7836A47F3E92EA
+ 09B0F0458986D1A1DE2995064C7F82BC125AADF4A93B21E409B646D818BE4AFE
+ 77B04B9AC3885ADCFCB341DCCE6DF0636B6BBF58C1BC34289377413E9E8CF3CC
+ F7CC9864327C0CB25A04F98A286EF1F1FC14AB3A19B93B6AD743F11CC5FC4A31
+ A8EFD5587BF332F82E04CDF263E07A87CAF576C8C7149F335F151642182F7808
+ DC6D60098B5F2DFEB6FA00118EB4008C3487A36625B66C2AC14EBA860050597E
+ C997A791DAD3FD736AA10690C955DFC948454116D92E594F1A30F7B150AB8209
+ E6E19F4BBF8544CE934106724302077167F50A371235866A951E8F363A6644E2
+ 36B00B1487943B73EC7E5FF60460615A8E9853855160F9ABAAF8F9C1038EFE86
+ FDE70B73F5270CEFBB285A775721221179BEA6E53CA944E23EB867B825B15959
+ 30DE78DA48E383C4E9C4C5DA8F30BB73D11C51B0BBC5C76F8B1B1D93D5AE0F32
+ BD244F093B39BCE035434E0440428029B8B5F0AFD4D41E9E34F523861AF81EC9
+ ED2708FB5B1AA9D420CCC6E3361EAFA2F333B44D6F526033F3D880C5EAC82D1A
+ 65793614FCA7CF3958B6210B81366E5BE43ECEB8446A3299FC4A182DE1934228
+ 1258C062F3A2BE78FB1BC9F3FD8844EC13B1E06A2AA5363B9F805905435C5D28
+ F891ECDE4A233CB9A408E31038AA2A70966872891835A0C6633D202049174816
+ 48B6AEA30B731490B902878755DD77FB704316C5B8DA3DD890084B05C5523E1A
+ 33A320484E810B00ED58837A96BB2DB7F0208E1FB39CF6E847B989D806580D2A
+ 321192E8017527D5AB6169EC2FD30E00EAA2E8B1F10C4FCD6CA60A6E82189E7B
+ E170C3FFDFF9632EA098310D7C39A99328E9B05AF8A5DAE71BFC0107F5E700F5
+ 58AFF2F8CBF2A26EA6AD4101328220FB6F47FE75AD7B2652B42AEC88751F46AE
+ 16F17B7946A70C085638E3737F6609A0AFF018CEB1A0EC78902748BAEB8C3B7C
+ AEB9211E65BFCB8BBD13B27A0014B76C037A93A15150567F9B2E72F2101D6985
+ ED911E7E7AF885D158512777193599F229585C9B1A8F82237C8019A32F0085B4
+ 087F495FC096524B96A2B614457D97BAA0320850C5D889E693941C4F1AC98223
+ E21330B9A54AE3E106574722A4D7F78B34B7C8F64D28B1E5946FECAE37CBC32F
+ AFFDA4D200B4B7545E68D645B513BC1FC8D3E033964339BAD419572A4FBDB9B3
+ 85796C49C828CE74497D0484A165CF00853AF724941958BF652CD4CE9999F8E6
+ 0DC120FD23E3AB8A04C6C38926FD48BA94DDB74D6A09CF097A1DC17A434FE38E
+ 687567F6CB6ABDFDC4587D8AF5EDD3B8C86B1A988EA7112D576FE3D97CC69A5D
+ 5B62BD38770296A35BA507B19D9DE4E77EE2D207EEE47D96995955B02C856C80
+ CDD4D9BD44C822B068B56D6C9FA1BA84B02BD7C802A96B133702EFA6DD9384A7
+ AEAAD9CDF154B6A9E2132155A7ABEC40AE67EB9CA77426EAED575DE34E95566D
+ EC70CDA670F07D80FC37C80A5DB0ED07394463F003ED8CDABC0E053A9C550DC7
+ A613AFD3CB3B518EC5806BC6C334087A16B64C0DEF692BDAFB6C2C38E76A691B
+ 101E696F219ABD31A1E4F2EB79F73ABE31E17ECFE1F2AD452E3D29472A5DA8DC
+ 2DAF7EC85F0347B4257B24633B9985D9EA22FFF2F92341DA277F2DBA0895E6E4
+ FABD78EB1BE576D1E86BD85DBC53A8608EF3B4AACC23D8D0579C3543226FBA0D
+ 1D8B30B3C3DD88F04227EB0F4DDE26C9F50197A790A72FAA5DF8E3273F3A3DC7
+ 9D9609C06672AB4F5EF51C18D8DEF803A78106EF4A12AEC482201E951FBDDF29
+ 310B562764A41A677F4F6D1F5EE4091D886B7931A4E5CCFB87125934D92C08C8
+ 2DA6AD072DBCDD6F87B912CB8FD07FB76513DBEC30572F5277A010E917EB00AE
+ B2C77D298F465B4AB9ADA2869567FBE83682AB57A7D447A1AAEFDD66CD2901CD
+ 742C56D8522315EBBC65310990A77CF2362587B91110736208E87516F07215EE
+ 64FB1CCE61A5B4D8B8D79EEBEFC27281BB7DE2A2337EC576CE9CAE471393CB0F
+ 1351246B53A619923BDF824BC725F274B5B52D2F67F3F4876C59C8A0A5103BF2
+ 1DCBA235E7F2DF78B54D3581E515905ED3977F8C81FEBC482C16740A0D400C40
+ 9CDB39FDAEC60198CBC7D4A854A3C3EB5346B76D72BF1D3A9047D658F59C3AB3
+ A0D8AFD9E30A0BC5D32901C1D66B1FE95A39E76BAC44DC846772858CF34210AF
+ C0B7A490DDC148C30487EEDE8DC60ECE409D946E53CC99A4D994224525060D07
+ C3C6FA4A2AAE7A241D68EF6B5BC031CC12CCF01F344178F329CECD6330FA0023
+ EBBF662D24F2DB2CB926F76BA1F31BDCCCCD3F2911DD7E4A9C9E1A1589AB3B71
+ C9370F3130B6BD0FCDE4429A6AAF8A8FB84695C30E1178CD620D6C8E47D7E881
+ E278AE30DA62822B3DAAEE7504B3A57A75A41E888B4FDF53018709EAB1ADBA2C
+ 28C4686F653BB9BD36321030370A91405D2388C4B1A3952127157FB5CE0DEE71
+ 185DA3776680E481CBFA713E5FD39DD716A8816C990F74D2F7796DC5A5ABFFCC
+ 10EC0789F25F5E08313DD349994CAAD6118DBBB5AC9E7C08FA1CF84E39A4D2ED
+ 5FD652E0F8226DD41BB8259341ED6A6099EAE2E35CDA2EFF8931CDB0FFC6B04F
+ D3AF6DCD26201B3A93D15AEFD15EE8C4D54A7B63E2BBEB63467B3CDC2126AF84
+ 409AFE83666FD198CD3DBB6DE925D52DC8C04A7FEB0C50B98D82F30AF988A610
+ FB751A693B8D24D6C9E44585FA08FDF5C14FC062BFDD0F41981825A6A3CAB34F
+ 7D49F3E78FD741D5E8EA44DEF5C39421AA20D9E4410694CE0C935FEFF50BFF83
+ D60023DAF2740A1B1AE6BB608A285F095E80926F934A50B2BA3EBAE4CF608382
+ C4D80C2714BAF2D1C9EBD14D2B3EB74BFAC27B3D0E763582F9289E4E96685045
+ D75E75C26E278B7D68097DDB5A5ADC9822A02A2AABF4B2621129A80F204A0AD2
+ 5E230884649DFA59D884FAA9D19B1DC207CC681A74C4785CA0C6CE45ED5E0691
+ E85B9EC6717E61C57FD35208FC5E26579CF852CF268A20314151647FEDA42A1C
+ 4FFDD26656CE07A42C21D591576C32367048C68909B787EEDA0B9E334FA306B6
+ B5B8C9B51DA1A6DF01E352130FB63AC35A9E9097541035CBCB330941F778126C
+ 7CB7F31E986A65F32AFB18DE6E1C28D47B01FF0B2857B8F55933D71641EAEBCE
+ AA6793BD2DD9B137E160CB7909885A25A9A62BD463566DFEC5B04DD9D79FEC0A
+ 03810664D7D9CB58BFB7EA72EBFAA8F77B9E78457A4016A408A2DD05F933153A
+ 78E879F6B171C199707A90AF68DECDDBCBC24887A936334AAC60541A71F39C38
+ 85EAA93BBEA067823ADC4FED17FFDC889343AF95E399E729F33CCE7CD522B6DF
+ EC650F2EB5060DDB0439497C6B9BFE9E05DC05C0C059B3DDB04DC02550F9D17F
+ 8BC1C4DB73FF740E095239EE7D76CFC550D8F0EB41795896EABD316AAB3718A5
+ 3A3A9666ECFEAECBA15AD3B09DF84C40629F4D15A7ADE7FBF2B0FFD35813DD2D
+ 4A80C67101B8EE1183690A20B40A006649E25EAE979F127C943C96F474439B22
+ 140FE9D71E4070F9617F5D823A4C4990C20F48D320849744E92E5EFB1AC11876
+ A8EC438A2278923D3A24D222D929C3DBAF42F97CC8580E352BF87D33B4B706E0
+ 1B76BB81E93BB9FB512E2862D989055E3900AFC9F2BF1B4E8BCE6EBECE772394
+ D88845B73C1DFBBD8B3FF55CD3775733D9AF2000BA9C7BA055425175D6349935
+ 516D7DA2DBA58D4002EAA4EFBDC04AC4240BA17DE028041A4C7E20E92FA17735
+ 492C59E8BA1FFEBC74BAA221A341C985775E6A6CEFF39EE467ABD89817558176
+ 721A6834CB85BC3FD4DC941A6CEF7CE64D5F335F9A2ABA8F97EACBEB04901470
+ 1996709FC285F4BEFA7F77C28C552CE7EF3939FF48C03A86FD47601973F39D1D
+ A2C328BF17E4CA7D190877F32841606898EC631CE36D83FEB60E77ECA67E13A8
+ 31DA7CA14F7C0CDAF6CBDAC67EE2FBB9551F0C89146A98945670D387D0591A07
+ DA1982459C12577989635A2F646ABA8A31954E45E33819D4AC99C804EB8B11C3
+ 99DBEE6EE82805CE9BFE79E9B662D0C4A33F2BAA4C109F3DC2F7CECDD8C8243D
+ D308F853FB599C829500A859FFEF179E4C2BD700558C66429995D84560FD1AD2
+ 5F56EF2DCA61C1BE3B386433FB469B5A0A1B900A2FC81D9FB06BCC2FCEB463EC
+ 3C03B2F825F189390149D2CC83A897F178FD125AD1446641854014B50532B4A9
+ 2BD1D8F7BAE53125B4335D52CE2C0598FF18CFF00A0976BC12613086F136F50C
+ 7D131F5A5A31CE4C95F1CA44C5EFEFA2FE51A664F6119CA78DA3D5478E6E4E40
+ C3F13519E57A34D3644C27FA8DB1972E6E86BFCCF0EE0D98AA0338AC8B30CA82
+ 8A1D33A86B6522D8193BD3FB8E8D18647EECF2A4FD16CC304D7B0EC8D9DA7127
+ C4DA4E6AD09FD7CBF1014F2D1227E7B7DB812E489F825ECDD443FF007060A40F
+ 0F4FA005E1D8A267F88BC1E07D4BC9DD7221D8830DFCFEEBFC6B35B95FBDF79F
+ C06C3D4E8905888615DC442D58461675F6C88BB2D8EE590F14D9E0338A9BF451
+ 63A6691CE1E964536340B15EBAA8D5D17FC471A3FF926723327593A669C41D4C
+ E6AF278ECD95A009FE18CE6A1E1AB089C844EC46E09CE45AE24D54EE06974A25
+ 3DA746DA249C2234588CF1EE878230685DB94916E7B43CFB4B85EDD8FB81D57E
+ 5178E21396D8B1D344AFEDCE6E9A3136A43098EDAE40044687AECCBAF625B235
+ 908AE72B7C3CF38A6E44B20097F10A423A9DF6D6A4B559AB2148B61646EB0F39
+ 2B696B036A296BDD70289EA235EBD077138211D47D5A39CE0333890AFFFD16FA
+ F48647FE575250EADA0281BB3326ABC7DFA6546D6A3690171D802795FC556471
+ 6516A533DB614FFD53F14BF31F69969A9D827ADD0AE7894E54E0D67CCFAF2022
+ 08D0A53B06E3C24B995B191A06C5939F7A7642645A73D6603B59BFCFC69FA1FD
+ 26417C63345E8E55C24BA4486C83E5F9E7D7459736B0DE1BC462A51158EDDB56
+ E4492CF68B11A0877329DCD0CA5BF7320000D93624486AEA956E896A7378F511
+ 2B4535BA77DA0B3FDAB815FF84334C1E477ED6E1D15962A8B66DFCCDBFCE1DB3
+ 2B1DFFDE779E286A7820CC2EFAD87EF5FFB603DD1E89908A72E5CA91AD637652
+ 30D301AB2A6A34ED54145C4D967CFA7C68B7D733B03AFD9F5F2A13A910DE3D50
+ 478AFC83EA796B669FE6E3429262DA5B806D43F8DEEF88BF1753C1EB28435C08
+ 6CFD829D5E465E6CD4F0B1496C547C463FA470ECD761D3184BE1F9C64D3F1A5E
+ 71CBA8E8FFF7EAED90FA71BA53406416B55444B30F5E911C76145566C2144E14
+ D5FF9AA6D6D697541E74E88C834ED55CA1FA888C3DBE0B12FF119407FC042E74
+ 93A5DE0CAE2F0BCF03FA4396813CA33C7CF36A50346C0E77C5A05D2C1EF0112E
+ 91E50D2AF1FCEA7C5D32000F6C40CB9DC6F04BFA3B34F520EC5C46B44EAE41A7
+ 19BEDBB05B144C8973441727D1B7265B224EBF08800D9D71E7E6E325DD1F3610
+ DA440998918F0E2818438E2369CE98D442A0724C7C649B3002123926A3884C7D
+ 5E59587514494880ED0CA10FB8CBD8AC101A5E34EDE20BC1535BB230D42ABE63
+ 88625D1F58BE17E1FA2A89049AC206D54FC28693241C44AA9DA2AFCAF6C42BD8
+ 6D09DBAB70F71250A24B114A7E80C75C07D00EC98E1D6222CE1EB2EACF251ADB
+ 93BDE8681BA0218C6750E47C3E90FBF780A80D99AC5D96435BA6921BC02D99D8
+ D376297EDD9D081BD8F094DA52E1102B0BFA5C6AE3B1806479172F4EE4150F63
+ 9E0C8BEC20891A2D8F7DBBE61BE89D667941D97245A2F991021A5F313DB03435
+ 5ADD100432394023ACCE4EAC62FFD0D1229023D7E5C6581E2AFC2B261BE8615F
+ C0C28A99C509CC95C3DB69D082F77EBFFCC2B497581C42EEF84FD770CBB59EE6
+ 5733BAEF2F5292AFB9682D094BEFF548A561E69FC5442974EB9AD890C6DD2922
+ E28C63C68758E79667B693A7AA31FF9D68404922AA83AFE22A050897E74B3B95
+ CE09BB09B55564959E4E72FE4B548CB60EB08BDF9A2C180E3E34BFF706D179C7
+ 6A4FA5D6852F3A49BB094399C6A112614B0606B3F365A71BD85FBBD74759695B
+ 8EFD060971289A8D6752184066B10C6FBB390549204F69B1BA8896673953DCED
+ A0F4551F9675FA4F5507CC80ABAC924B0F027FBDCC5BDE82BD03B170361904C8
+ BEFE92209499F80581DAC0A21F25977BC26AFCBF11B91EF4E454201497CD7EE7
+ AA83FBAF735A7DB405C97AF0D4F0A71CF22F943200273786EDD15521765B5F43
+ D4935988AFB8DB7C45529AA545310D6B3624F381F8DE281B33EF4870CC04E76D
+ 959F97570BC4B9AAB2C1B2E3BDE65F4F2ABEE6837FA2CC3A49845030153E2BF1
+ 07594DDC2DF086300AA933E189FAA88E7110CACE1C56FFCC63170AC8426C8DCD
+ 68C661DB68FC406D4166D819EDBAA0D07A4E144943F03BDC72AC0BADECE79424
+ AE666B71A1A47F02D6F68F662603348EDA5667C16741C52B2B0EA55819C1B189
+ 23A8745680936C37D5BF2A14C5895AC630E4F22F42387992E549C27570A01FF6
+ 4C54912EE5A4A0279B8571F746DD197B5FAE5EDCB59C3F90EB9E3B505FBB463F
+ C20EEB524403A0DE14B5A991CD52A367B6E8DFB7C4C66A66F15D737DFD7FB888
+ 6970A584A8EA56B28BA8489AB702039658AE2519405EC4944474E3A6CC7D00A2
+ 663F609C85EDF80A061A530159145A4746944D50682F2986590AFAD2CBC9C7F2
+ 25068100CECD13C28392312E39C23C693B9069FE47A667307EA221652A3EEBDE
+ 81191F3E2AC53A7FAEDBDF3E34D4C8AAA902B3F28E6D0B87751D797FBB5D01C6
+ 8965E79296E23C88E90E1F077647F61D2A9DEE4B320453F2B1F9BE5BA901572B
+ 3B09C22FF50D728CB1601698C1D6406562991FB2A2ED41C1CC9FB8FCDFC36BBD
+ 94EEB42B9F9D6DAFC670DA107E08D6D770BAF0FC815F812D4AA72677204F8A57
+ F35EC220D9EEE1C00B66AA94619C79C77BEE4D15A56B8A88D3272E55A6F4BA80
+ 9B766770CA3EB10BCC47409D4AD35A79326D2D0614DB86750F9BE78291DCAE6A
+ 94EBFADB86F79A7AAA85148F868DC831B357603E3AF360D4B4877FA86FD60B75
+ 1598DF4510C78A6338F463D1EEBED2FD3E5D36A691EE981446889F0F6EFCB707
+ 25B849CDD559ABF0153B91CE5315D23760B985595FA0241D5992BE9F66487493
+ 6E080C0E9E498A350331CDC99FAC2C227F816703CB335FA65EE19DF8BD4C02FB
+ 3543122CC8467EFE1BD5CB36AB5F1BCCAFC7C22E06D6B66D0EE90E7C75D487F7
+ DAC8E838D9BE185FFC2B0161A0A2B852F07B42AFA0C0109FD445B45F54C2FB0B
+ 9E1A7D05EE6F36DBB404A1499800AD7BBE69E45F68CE5DA75C92741C071200E8
+ 1D494B703C71B488F75D420E3CCF84A44DEF5BFE5E96D6EF5672DEC0E2761193
+ 3A956AE937663C9DE2D369F2BF719220F9B79318DED7CA96D69AB05A01B57DD4
+ 7A9F0CDAFF8A8BC490D61E3D6B908105D4D195D851656FFBC0A3F06044DEC409
+ 1FEDA6120DE9D2F049408BE754EAA6CE95851FE8E9C69C7561517BADC0BE4428
+ 39A7081DE85CACF4A70C535E30D431F790EC5317D2056FCA0ADDE37438B19753
+ E205678AC1B4800B9B87D222C1D38715A1D97EBB0E5C6E4683C862627EC7D178
+ 302A951A4346D7EA3C0E75E10082DDFBFF9797E0297B7F8F295C38C41974922E
+ A5FB2825AE146C454D5ACAF63A8CE93351746BAA802D75C62E70E71F9439466C
+ BAAB3B16ED2DEFB917E83E3C76455A90A503D65A521080E56A828A09B9961EB6
+ 7721E0F1039D56A84F965E369F83F3E3C5528629C81DD0898CF9B3A0BB86D77C
+ 1D5BA668764BEE7788DEABB06A9374C5A6291A2A99657D99F26941BCEE30CE20
+ 5E22A23BF66432C15CF7830932815944C6CB9BECA435220821228950B3B6AE4F
+ D6E9196A2EECAEF7AB67E411E59A4D0B5C699931D5683E2529FC9C67EFA66CC3
+ 8B9EAD33092C7A04AD1CD80F93C69BE70ADBC3408FFE0B19DD6CFAB55373A339
+ E81B67CAAC2A5607091713DF177A8D8186473049840DF225023126F385439E33
+ A391C5C1EFBE1B2A0981CA0CF6FF32A5B76203756D250002F6D87596B79BF2A1
+ 77CA4D0594333A3F794E953C0E1B7489BCD676B22982D5872A88FF8DD25FB0D5
+ A99D969FCC63E0FD3BAC9D923C161EA0A0C01B77718C18AE52ECA905B590BF90
+ 809ABB389964ACED1D680BF4AD6A47E08D9C1A58D2809ACBE0FACBDB7ED1816D
+ EAA91488B53F639747C62729F1102C108303841F1923AF8BF388C1261EFBDCF1
+ FAF0BE0E19E10903CC9B4AC6D2E54FCD910B6090EB37F225CA010E716854E532
+ 621B42FAEE09FC23F086DCD273D1EB96B3136FB3B27E9674DEA4970C87A3BA1A
+ 23D5387D9C5712F29DADB31943BA71BB06475F24ED635F91A6B2381D15B5DBB8
+ 2A64C63EC93948D3F3052689CDAA576A987167F11A708E8FD98DABF42BC7D0A9
+ EE50C4A0A1578C7B95608450A92F6714459BD8B57F346E792A6662FEACF3B9DF
+ C7F1B137FD8D221229DC424936C38E47F1C977306289F4C332F71949814E7B67
+ E7DADAB2A22E3DAD5D1BA9662B924F3AD9DD56C8AC6B01493B4DDC5AA119582A
+ D0E881F937E3B4A68ED4C54B88FED7D13E3512719ABE2F1975EBC9C5B6D7A4F5
+ F1138CDD62CFC67CF7D1857EA8B20F476DE2DEF30B4FB61A1A10CE1590C585E0
+ 79A21FF1B24ABC8AB6ECF2D12FF90F6F1C6F1BDD986471E948550D36542F457B
+ B28EE92E161F2593B13950ABB09F7984BA756102290681965BDFD693790BE3BA
+ 18159580290C122115E01A9B6C535A2A7514485EDDB79719ECFFA2CC0EF994F5
+ 0F7F5AD35C4DC726DAB05776E9C0F91AB7B718A8F1D0E263D41C1052C7038631
+ B95F5344FC82A84B976E3935E496B01BCE80C1A710E2BF08D8BF1C9C90EA4E1D
+ 6B8F3E81728779570E6E7D5880B7B277ED584D65CAABE492B13011FA0E27FC00
+ B0655DED573904311775ADF8C437B939262707DA72CF36D2CA0CC7EC43EBF650
+ 14F9D820E59437EA63565FAA9DB37B72B50F30843EACDC08C5C12F2A5A32AD16
+ 59DF2DA046D728F988212AEE561C208636E5BDC5D51F8CE743AC0F51A316C0E8
+ E7084A836B01BBE52B4AF4D577E1643A274850AE51CA03F09A78BAC6A3852DD4
+ A6D3B7057D1941C2ED9BEBF7FD9E778D6C78DBC9E4A1228B3DC2AE3D2C5BF29B
+ 0E9D2E4D542AEEC7839AF72944E0DCCC42D9D5B87EEE23BDA5F0AA2B8C145D31
+ 2A9546159AF23E739DB146DEEDA0946B98C70BC84EC49DEF3B07B675AF2B850F
+ 8E72897D1225505CFE2168770E2E00E0C56047B4E1832EB0AAF800A923849AE6
+ A5AB239C96CED60EB1FEEEEBC87F61B7D09FA7DA506AB45B69AFDBB50DED2B5A
+ FEDF3CB2F057DB9F3D41A2084CD35BAD3F3DBE3130D203A49274FCDC0CB96B69
+ D3853AD92FA48A0E55548DDBC40DBC967C61CA1722D539AC5FF2A4F50981BB14
+ 69D7CCD55F4DC30B9782A71BEF4A800319D660B72846DDDCC784D0E5BE931671
+ C0776CEBEE06638040C680273176BC00F78DB504C02AED2C12AF6C8D26AEA973
+ F4C5AA3B05C7180F13A1D8AECB5AD1FACEF985A153E1C8D2ECB5390A4CD010D4
+ DA9E1FF794EB75A012BAB8180E845BBC01E21113F8866739E5644152A243D4E2
+ 235753D3C09FE808F0F24D898C1D0001E16A98487395C8E7E14127E1C2B5AA84
+ D1232BD563B65888123946C6011D3D62E025AEE9521E1287831A397063C21A81
+ 1B3C6978D264B6E5F13DEBABA45D0CDF8EBDA71F1BED1192859A85473B96C4EC
+ 601CDCAC6969714EC2D962C078DC31EF0F30852E10E3CC9C2FA31C2ADAD9418D
+ F37394B4E987887CCF46EF77E68CEB4216381C5DBB03DB0622E86692AE220884
+ 33CB822FD9A0C0842ADB8CD846A42752E1B0A763141E9C12DE50B5E7AA65AC70
+ 9E6E7D2B98396A1CA1503D6E70EDFFE8E59AF260C1BAE67E723AE6AB93D7AA22
+ A0E1553F08657776B47B65595E4C80B2B5854C3E53B265622CDE95FC8C450CFD
+ F3F3F0C3E726D5835A0F241C76328B87BD24034CD4149D44EEE0900E12C34A5D
+ 1B894584EA19D796729AAE72934246BAC2E297B67C1AAADD1CD128B77FD33318
+ 9C77CC3A39D99C46D7EB493434D5755E1A9451156B7142F8FC6ACBDF5F164201
+ BC6EFC4E17EB89E89D82747AF022BF12932F304A9EA74608F7556A2E04F1FD7D
+ A0325248BA8ABAD11557B8CC17394F66B5EA0180B7BC0ADCDCC10A0DD00D2D8B
+ 6ABA03663B4EC94429E35797F32D17C51D1B84F99B981E76E88C461DA28F3577
+ E23836FF412DB62EEA86152CEE704D6097997E3CB73736F64E39CD7496E6B56B
+ FD3F4919147255E28A834E0E4D3312CCCF26B5E87C6B4C9491A4077593C16CF0
+ 42220ED6ACBC6D45042A440EDE4644FB7577A647BD221467752571B5C9774182
+ A2E8908FBEB7236CC327FDAB75097AE989EDB98FC26FF6DBCA4D3960D9076D28
+ 5D7914CFE211985D4B5AE89E91A76A498169CA319F3A77891C85C9DC73AA16BA
+ 8CD558FE6F0F0BEA074544F790BBAFBBC5F919D4DCBAB14163397C35E5EBAB90
+ F85418172A45FE1591D14F03F7BD040BB5734F516062955CEAEE4EA7A8024BD6
+ 3446717366F66F312C7025346BDA7667F098C3417035A6E1C6CD0A28DB13A7A7
+ 2A5820DDF6B393DF5104D2E9D5A2A01EAC67E11C7368A6C0C067CC71E89930C4
+ B206D715D1C1DB9E2085EB1781996A2449535EE44893B76EF8CA5FD03910A000
+ 1CE01DBA88B4919A9F243A93A9F5062356ADC497E707D39E13E68C942C6A0DE0
+ B0947B7484BF80E8D49C36A9FAF7D82E92738F7DA35A5B209FA83362223B7B4B
+ EE0208149E1533850D6E273D49473A97C931A2723697A6E3EC4E10669D8038B0
+ E549084BDAC618644F719B0ABF60E5D80037DD69F518CC459A8EFEAEF9A26E9E
+ 52F99332B2642646A03B376F9C5CE9F35082DA8C2A7506653A1A87A4F7824779
+ C2044DB2E3C4325FC1F6B7498EEAA9020C029A16C2BDA9268964B158132299FA
+ 8202EF498D199F4A6E86E4C3B03AA733861388B56349C2DCC54AACB1BAAAFDD3
+ 0A83EDAD04A9C43ACF166AE3C4940CA5C408D7E1F9F57EDA3A3352EDB90A62F3
+ D64489A098F25E1E0E33D7AD245C9BF747BE6BF41472B19407144176F5CF2CB0
+ 5CFD77412FA84D715EDE78320D3A2E065FC8464153F79EDEF2B7C6528E08D9CE
+ C33A728A96ADE145C727F357B6C6FC4D12AA852CD2D9B67069D720179781F091
+ B3C96C50F6FF1B82202E844F93B547913952D65D1AD2747AB7051AE85953F982
+ EA2F77615164EC2F64E0F01716E4534C0FF313AC70470095288CEEA9DD5C2A5A
+ E14B3C00AEE66E83471DA57A74A04F2E2D26BFE0806C0E3AD72D274688A2F626
+ AC198011BBAE17453232373FFD43543B7D2D8612081865E529073FB438D245C3
+ 81EF2464D158B63FB11691B809C04BA770972F1F28356ACF7FA6A93B62A395BC
+ 37B5E0A7856E38AF59C137908F709C9D36CEDD09D322FDE176994E61D62B4783
+ 6EBC2BFA8DD8071E0AC3B839C6BBF5BB53489D99A5B9FDBB39426D19BF7A467D
+ B96B985861187071C870780175A878666707F79BA65BB6282190B750380769C0
+ 062B990DB17154FFBC9E0766B47A1A100AA7A528D4C762CB6D12AA263E12226E
+ 240EAB39B697EB666D83815E35AE227F808BE112153F8D5EB94092DF72059FA4
+ DD2F22C29BF6586A0C74143295E0C48ECCE33C38FCAC0325DC34083C4537D314
+ 30DA0B61757CC665C60637B7FC658BBF032EC6D71E38A346D3FEF90C1E58EF81
+ 4025B258BC06B4287A58F6F338C49FF7E291D73418E84849687B68FF5129449C
+ B71D9B496AD29BDB6B1ED1198554A53463AC6B6A4C64BAEDD82651AA5D6EDA15
+ F9ED5431D610FF23093C5B751E6A2E34E2254898A5AA8C2B24DC9E51090A7881
+ 6AD3A9E9C6C40673817C9EFE5DF8BD9A87E68DB56BAC5A1A1A7DE5C7F1AE5F0F
+ 381AA3E7FB8D058FC5012A4F3EE369E7D5B8725E2F9D65FF4F330CCDF5A80410
+ 1814E5C7A51A03FBF57B55F10F223D3FB2DFBFD0F1CFA97899C7C98BDD36B489
+ 9C7CD8D144BFE38184155CF7334B16B109A627966853E089149B60EDA2711AB6
+ 54D9BAF5A5B58E3019B7AD52F5685759464E5F8D354A57767162C4B6BEEC16F2
+ AE94A515AD7A14C972F79810039ADC4978438C7212AB2D13881D22F4C551B36F
+ B8D81734C8E555902F6381EF3D9874DAA72E2BC5228903653E4A83325A6D1898
+ DFCA87B86C620B65F953303EA32F13E00B48CB16A4AD36C3266644A37627FE2C
+ 292B8FBC5E434BBB88189D357D3D1A09BA5C6C7E2333118CD1F2325F899FBA60
+ 0DBE0AE2A50FF9BEE8461EC5CEE427BEEACF13840D54D395502298725E5F2E52
+ 43D6ECEAF2D731E11D3095D1105CF2E7D82925E61FF40BE0BBA4A246A48BAF4E
+ 72AFB5E7708814E2FFEDB6364581181DB5227F4F6845C883932CA494AEF5CFF2
+ 0E810F5DDEE6E6BFB92A7057114B2EDD07DF64F0A8551598453162B18432C4A2
+ F8823BD7B2803E11DBE934848A890BBA94CAC3C2057DA6C2F2354DB2DA5F584B
+ FF1647A6987ACD2E00D930B60B1D82CEE902F5D8C5484D6DC649D250C21EE7AD
+ 4CA6A7B444FDEDD2DABC93860DF9455554F4FC03EF08EBC054BD6E60748E0C78
+ 87959A2136512C4A3D7CCFEBDB9753DE99C1D775D3BA0D063FC15DBCEAEC6F43
+ 2364FA2A3B6A8214C7B091B054837F169BC69518B57497A710287D3A38819468
+ 868CD602F9F6BAE616A64BFE863E50E1C35760B12DCB7E3FD77AB339109BDFA2
+ B4EE467781319AECF01C62A471C536D40C9278CB8496E215B8D1638873A18F39
+ B9F8D77320C35E3D0E6469B303D4675B5F869F938C7CB1C869E69DA8DCBE9847
+ DFD91C5D20726C495D327AD823AB10FBFE63CED2CF6E845E4C2ECD91B2B32E00
+ 262891FBE14F7806EE62B39EEADC987E59B5F9B8C66F3337D9A0CF41CF680AA0
+ 0828145769774E409EBB557CB4E25FFF9DDE0F4ABF26AC684EAA0E02D9A9A8DC
+ 4103311A47B87AEDB09498F12CA43AD60B8A7200F3BBE9C3A62B2E7CA976DE9B
+ 19580C9542D771F8DEDC5FC221FB3966D7E3B2880A17B7A0AC15E423DDFB6615
+ AF3DDA48711173F4949CA3C3CDB6B94EFBC928E133D2651A7D8D2D2FDB615DFB
+ CD4A7FB74EC47F2BA160A20AF8A6A793065F77D256E30935D8BB6B5F85C7B145
+ 6C5097554670C96CF0CDD8E2F5A56B2E3DE9266AE623B968CCAC79B228CC4BA0
+ 4BCCAFDEA96CEE711125C70B097FFA99664D844551DB23C8959D013BB43D404C
+ 11680142B9F4F30F8561F8D9D7EAE7D3B2F9B4924D39098A65B2A31C7772E9C6
+ D1CC8BF61EA4A0F237ECDF3DA1A7104E8A16CD0BFC23F6CBF4FCA84D419A8239
+ 52AEF2CD80C150436B385E11FDD013A7A4B9FCA09266ED1AD881A4330F6C280C
+ 7057CA3CE67625A0261EDC82B4C46B7FB35D3F489A4382ABE96DF1C1AED00449
+ EBDFA1830AB7F4D5FD962B5727ADF23CF8DDD53F0601B6C1B359791FC16BBE81
+ A87C4445AC3BFF47DE538A0B9149E0FFD2C70CD9E3710CAB0E3CBA0557EF1D7F
+ CF59F1C5EE80C9B30D98725DB1D6C71F739EFAC1779714645BA1D8E7AC133635
+ DF1BC0F42E086F76F99EFE7E94715928BD9449DD867B071554B30E04A32AE615
+ 299F1E3F6623A49F32EB3D4AE4A4D7B8FD0F950F7E8B0F8BEB228C77BE95522C
+ E2AD3CC076B2E763CA7C8435BD59C1BDEFBB92D50CCD180AA3CC48E648EF2CCC
+ 2D396738A568A8B29A742BEB1BDAD022766C6718A49325082935CF710DD869B6
+ 4BE2BA2E8608332C00476C21211E59DD00E61CC8612B117F7241981C22607FB4
+ 13CB8B0DA39590FF96B5FC7C3BD6C7649593740E31CE4E2A4864FEFA1DE6F108
+ 68AC6ADA104C4B118972FE47C4A76646F3C9C542509DABE6D4E47BFC88A65FD7
+ D73DBF68FD7CF09715CC3D837ABB20087B1BC92B94DDDFE62E953CAC86C63AF5
+ 574978D4A67385D93AD70A5D8A21A9E00F8A353CCE497B1BF1C3C665D8F2774B
+ 80F60853FC6B7E104F49192166A9D68B77AD94699BBB477EBBECF9A972E6DACE
+ 38E396A7424B4683B9B761BF2B290EB95F360C7B1AFECF78F592E8C29DDB8EB4
+ 113E43ACFF9C2631A1A7CF84E5EC246237E20BA40EFBA7F40FEA34C6BD2CAC6C
+ 8F9B3AAB7B5BC294CE37DB6D42D909649FE842EE6C6242E77BE63AD2CE717A60
+ 01903B470A7F4F3B9F6E4C3BBBFEA92ED48387135EE94D74589775FE7C5A77EC
+ 6B2A15B8A67B71F2080F7671C4B0DF6B5CCC42FACEC2666E9F855261D8619054
+ F784E07292D0DC375023A96FA9553CB062DC94E890E039B804682F0E652A8313
+ 6F046D141B600816A5F41CD92AF131F924126DA1B5CD90893BD4D4BE91655A43
+ E70A27C798B527BC75C8C012BEF99D8256EEA91EB1D256AF60EE01B24C6700B5
+ C9C65E62677DF64D28493E3220236DB4F623B67D35C8E945E8F7DE16F80126C7
+ CB5394A14651F588474E01FFF0D607D1B69A7322643A04C5D625AE66C1F4AB8C
+ EE419E84E295F4203AFEC6ACCF3C69ACD68A90E7F35ECD40FF5E21161A411A9F
+ 5CC2437B4CC6C3FC753134C97C6D8D6041704C089E8988C2A15D43E918500274
+ 23CA4AF399679A0BFA48FB073FB22BA4A8C5ED710AE283FEE1BA8E1F9B87A992
+ A4CC05F549EF4F83739796288D6060F03F0CAB39592330E49BCD7D066BE89D1E
+ 8997EF39AFD4CE129572A98D5C1A452970CC7A39193EE30C19578100DEDD9756
+ 13C045A200AC465AFA9B878E2F21408DB9B0A8C3F5246C03718443443DE55C5B
+ 3A6016CBEBB9C974BCCB0F5264ADFC3301A71CE7FC7AFDBBE86748BF036F62A9
+ A4849A763E8553F318FBFB5D02C40C61C58A43ADE39C13C2611EE5845B09DFDE
+ C2A534C5FA1238CFCB5F22A340F9098011A17E93B27E9E3F170F497EAF826304
+ 2E3F9622C36DEACE220B3ED2A4296F2FE8622CAC6AF1C8426F8FAB0CBBC08790
+ F922F4F21E8A84925B916E687469D68E133D997BD81BB5A4A418FC2E731846AE
+ DB9D30E6365A606EA56D7A2360B711B831E2763E616A00D1A4C30DE862F6FF41
+ 559328C2281F1519A9DCF675360C9F3F9146E73A7DDD6665BA1E1ECE269CA544
+ 4115258A19F38B31F656038B025F00B5E6AD9E40D4522A84A6F70A66B16BEF76
+ 597F9909DF0DDD5E2DC4B8CCD92B4DEC5D00D21AF718EA564AAD1EC82938A7BD
+ E52CB064DA328B22E53926A96587B74466A44657B3BB72D6369BC46C09B1E8FC
+ 7D34B35A9D5373DBBB0677A1597B4EDA51DC4DAFD28DA1A41618B8105B1AB2E6
+ F9DA635D4E5E00D47BDE8814D71EC350A633F2EAEE55745BC9A2E0944A98ED17
+ 46ECBA51F664F34E2C93988E76F1B96D5CF747D5F02F2A5AA230C95E44FE7CFC
+ B59C40F32305B7A41926121C4CE3BEFAB1FD4A3C95F8A8497F4BAF2419F97467
+ AA6F49D3CFF701FC31072152003D88634A242526D28FF3AD5F6BB4C3F2D6E2E6
+ 3A0D750B3159306EFBE434CA40805CDF39B81141963E6D89A709697823687C99
+ E50AC3B730598DB1F9E3E4B7A7F26C88F2D34B0D97A20D674118DBF2EC7DB5FA
+ D3B2310CDBD81D7DB0CE41E8363B36D18D05BDC6BC312BDCDF1282BF616852CC
+ 17C3BF53B606DE9E5C5A5EDDD75B8BA65F209AE752B1E0D8B299DD52E5DA3074
+ B41360EFA42DD11F970E9C015D3A9467C67119207FBCD14819AE42248CEAE2B6
+ A3D9FE1FB0173138249AB17BF21057CBF1B58DD22DC396B8B529FBCF9EA57CB9
+ 82ABFB728B8D291610A804C48669A211789419326036216FEEA7C60A2F5C046A
+ 6DD795D83A0089379C80FA929FA89D49314D02B64BF0DACE80968E59EF8E2227
+ 74B318B4E621E54404995001C9876C380E436DDA922E8A3409BE49AED6D9F36A
+ 388B22A808FD68E36AB76851E24D8A89202C1E68C902C1232ABE8B99305F60C4
+ F0B83DE4C11CD8BDF4DEC503BABC2951DD4CC976A5E8ED3DC36607C4529F60BC
+ BCD5CE7D0929F309E7973DCB0C7470512B105444CBDC2003973F28C29E150CE5
+ 84025BA523998B0EC703DA475644EF3E31A0D429A106C6B8080D00B33DFC4A84
+ F88943CC0DE49287C17A16C5A165D4CDC6C9059AFAD777F904CECD4FE0CC4A8A
+ 3670804333F6DD67442D5252B63EB01194A510E06B7373A6FC2D11EEC3C7F1E2
+ FAC6693215648DDEF9BA91378FB1BD25A92BD0BBA44000102617AF493D9B4E5C
+ B9FFE0535CD21F55AFDE228F88AC8E5B0000F9B208FA167022CB8333D29C7EE9
+ 166748AB38E412320F5C2DA3A1CAF458D79FA9DE7EF7D996CAF5842EC0F3E13B
+ 2F69DBEBF0E26DCAF25DD535B239BB55EF1116C4B72A03D5F9575F6A22646FF7
+ CB494387AF10B76906EDD5A3CF1DE2CDC9F69C3081D0E9CF6E9E38E7D6987C25
+ 6771EECE59131EC41B7E20705872CC14C430129713D453F5C19FBBDA0EC889FF
+ 528E45CFA01A3B89E193DD532BE8BA608E828A96D2630F1D37230B5CA8538359
+ AB1713544E92BAA561349BABEC8B3353C55FB1F00498A5F27B14A961EB972DAD
+ 57236BA9F571EE79E6E5DAEEBF7CCAEA76493F5B3846D7086FF457D6BADECB2D
+ 57ACA32E33FDA4EAF31998A953F6AB9C5A9A168E6ECA10846995B654ACBE4907
+ CB2DD93A2E673F7272FE5B54E88D8EC16901D48F882840C98658CD8A5FB44BE8
+ 112545FC21E2DF4E12395ED0CFD367569004DDBF165D7327A8B18625FFF1FC24
+ 885B9B44EF7FBFCA65791A2F070B37CEB7390D8D7E710668F79942E67336E788
+ 410B77D4B5ADC78BBAE4DC5E532FE0BEABD446EE73852AFB04C480A2F02E984C
+ 8A55E35D3AC57AD1B8F041C928D9696216DCAAD9F292AD0C1F1FB2AE016635C5
+ 345E725D794098617555D7ADABF476DAD48D070D2987B3F1AADB90D6F29CD3EA
+ 27BFE15BEC2ED745AD6BBF1A49D4A7D77A7E82584B7203FFACDB56AB6E9974DD
+ 28797CFCADB30CDE95C6049543AD6290BECDB00826AEE0F1C03AF9F0580A38CD
+ 73B5E8DF5C58254CD6863A91EF0FAFA19D2053BB3199CFC6D5C62D2BD2541132
+ 99A953417F88A6D8B6DD2CEB67C2C28F8C69BA4B23D5788697162233AE60E4B0
+ E69720198BDD4ACD57D200619A8EC1AA0A8DC6A42A042034C5C3CBC0E128A483
+ C3159145DABF18EF8F7C64A354F78AA0767555E1A53666712A85FD704786223B
+ 80E00143064DB2B8049E0C6D3B48602B7061CA7D9F7E2E18C5CA162103FEEFC2
+ 46CF31275C9ED36F9F81A3B55BC13E7CBDCDBE8AACAC609D82619DC0DF63D8B2
+ 540471E31BF4D81818A796AC929C58006749FBA0DD95FD7FC3733D4C20ACF9DB
+ B8C064F86136CEFABE8B1DD5EEDBEDED967C9C909D5F6B63D11E60FAC94A3D66
+ F46A07BBBEB6880C127F2BD11E8932038E2D45D4E069059EAE7BB89B73D6BFA3
+ 5EAE6EAD71C510EAE5D1C30622F1CFE85A7B44C4F70558C1898B737B51C958BC
+ 6866402DC4E4BF230C618CF46E933B33448CA069D290DDA0557D045E39F03EB3
+ 1A3F2EDBB8A9D8FC3A69F89888AE5089687C34541A94DBC9261164E1D869B347
+ 9F479EA6A2191EC725A654053EEC6BD60D0C5B1D9C954236B12731F554661CE3
+ FC633DEAE9B80A31D4F3A309B4DE7E5611F76FB37EFDB3E6AEF203155408176A
+ B50AFB57A54C5B7593D3B50DAE1E08B18A61654A33368EACD705AA0A6B318C3E
+ 10D4E3A54D34AE0C1C47273565021A10DE373BF8D87759460BC472269896AE33
+ A09BE800AFAEE9DD48046716013B4E5F816410707406D583291ED4724F1FDFDA
+ BC9D2074A92D8B73BB90122DC17A7D080747DD12492692594FFEBEC31B75012B
+ 98C75717F77BB6EDB93FDB18CDB1DCD17730F4AE30F1D8FB587AFF3EED240CA3
+ 5265D79F66CD76C6854420412FAD628D85CF27FF28E32379E9560132275363AE
+ 5786997EEF98A8788A3C83CE4D697CF6004100964B967D37BE2680DF37D23E75
+ 263125076A34BBDE82A98717902FD6D0D454887F7E97795C0ED05BFBB56F2C51
+ 2CAAD16DB064283BD3FD95556EFB21B6C08D3240FCF5CA30BE6E6799B0CFA5A2
+ 1B2E11308DE86CCD787B1C1D242D503DFE4BE6C475D62E2A077C747760C208E3
+ 22359CEBDAF48966F6E9A8C4DFD54C5E529875E0A4ACD2543F9D449F1FB61771
+ F94667BA64D32880B1D40B570B8390BD39368EAC441F997B2DD38C9F81384CCA
+ 701E26A70998CE37CC36048CE88C141DA5B654561560D88397DA21E0FBBF335C
+ 00F8E85D7EF45C97908FE58242247E552FCA9BCD4C8EBD5A990A70004BE23617
+ A528B480DFFAC8AFF64D905BF3E6967C49B49A51DD8D763847A9A305ED545049
+ 552AD059260AA0213D7C607F6C0CC81ED69696BBA91B849236638C1429961A78
+ 5705DDCB98D416B01C81D941723A98821244D16E390EEE877EACD7E073AD5F5F
+ 2B2F7F58F8A94BD6B99BFB6D8807B62517AF5B131E33AF7903F9C37064226A61
+ 262FBF82252BA9AAF386BEE7F1F40F837620F1B25FECA3C42893ECC5A22CF907
+ 7F9AC8C61693300BF708BB36D7EC2C962C7189261883649E19B966CBC65B1B67
+ 885F18B2F5510A6A8AFFAB4EA70FEC348595D4E6AF209BEB776AEC93026E7B3D
+ 4BD56998CA9581920EBD8E8C16CDD4D59F3D8FC5A30FF7167ADA681F26D700BB
+ FC2CD12C192A1E0ED5884BDD2DA317D44FF93956F7CCE431F8FCB37C8237FA2E
+ 15C954E7501BB8F2D8B2FE887FEB01437101E906FF1FA0178BA0313A1843D893
+ 5103A28BA57757F8015E3D30F512D86E5BB0A8B769C1215800AD724EB37BB00F
+ B9C33E9356C2D7B78571480A553A6AE30A75FD6A53471B63EE62D80E2D56C712
+ 6A8426BA965D84FB4878C79D7248580903C90E972F2D63878CFEE572A88BD08D
+ B323E7D756906D95607EE0482204F17FB322140E37E4324EEF64158551A1FE8A
+ 3186707B1F79393AE43B6A06D4D90E9F94E4A0CAE47D28ABD903B47F8E780BFE
+ EEFBEAD19E7F77DA375A5F11355529B3CCDB71ACA76A0EF081082B8F2006004B
+ 5E179CB5ACC58FCAC42DA08169074334C926F2807C56645FC36833693E905303
+ 34F419735903D0D2DCC0D4DC0A84702A565CDC8D59B2B5856980B44C93AD2554
+ 6BB8C8F63B5F5BF15DF5462286A2E56CDD6358BDBC6D180DB5C1B79B8B0F975F
+ 9D52476B9E5B57C6661C47A2E87F476BAB62C4D3E24DB2D25562B4312326C972
+ 61F932022233933E5FB107056C606BFC79E7974D7CCAC3A353975430600144C4
+ 92EA9864CCEDEC277A1B628167CEC9D157E040AABDC4A45B3E873A38C42846CB
+ CA61E753EEF36D2E85EA62A0DBFA9551D48070872C9E940A91C85FA9AA512E3B
+ EFD9BC5AE7DDBF48DFB0172ABF8BAF75CEA718F4B4A44AA9F052AC4E54FFD64E
+ CD047AB52FE68DD536F91DA3EA560B8D7E8D61A4EC02432C231CB3AB7E7F07AD
+ B2C533DB69DA3455A7A0F0F0DF280FF973D6BD57B5F9448C0B02B642E6E698A8
+ D08C869367B1D13F5E74A70F52745B635D3A91F01E0022192520980DF7F880E1
+ 50EDDB0AD9AF30C07E7C2CA953683BED8AB4C10B4B9CEF4EEC8D9A4E3B23D6FE
+ 08FC28F465231D63303294D7AFAC0442DE88DA76243769BCF96CA139EE4D90C4
+ 5B7C0D861C2BB9472F2EAFCFA5071D5AEDA255C86AA51D45EE8ADEC2FEF6AFD9
+ 5894238B5089422799D3D3827563CD7611F1C6ADA945D4D095EECFDDE251D3DA
+ 961E458BE5D1CE56281DC984C1D11C6078C364167CA3811492A25FD6A08DD689
+ 7F105F26286AA6AD703765791248F68DA8EDD415227BF7556062770BADFD4E82
+ 2B973D1162857867255B1C19A2D467BE18408BCEB55B0254CDB2B4EDC5DD7F6D
+ 9EB5730C69DDDA161798F93971BF6B649B4693282C68FDA02223ADCC34758463
+ 8C8DF0ACED1A973F913F9598A1F6E81F4588DC8620E5F930FFE72323DB0EC0A0
+ DE730E4DDB27AFFD5589A47E19E76E9F8E5B67B261009E01CD834806DAFD4B0D
+ F323ADED7D13A5AAFCBE9B6C97680DD2AC795403A176FF06E7D3EB45FA8ADD88
+ 1948DE04E37873172C39F6645B1B1885F489E1D21A5DC2DAA523E5BDE832AB21
+ E19D7DFBBEF14EFF3515E82E647F67FF83765E58D327FBC66B1826B4691AD650
+ AFF337DFE14A757537C3B48D864217EF13D953E6D3015D5732FCFBE650AD375E
+ 72D0FEC888135770A84281133CB16D7921A29E131B6DBA20F51FD27538D94C92
+ A3CB360BF36EA33D6C4EF250B07FC5EEEEEF21C65A8602328B33701AC1834CDB
+ 5F70A33825AA741FC1586709A470C2BD79237B7622F5EC8166E0F68E046CDFB3
+ D41740B884E486816D890152A847A1494178EFAD770A2348724930904B82651D
+ 2C414DBAF50DA757F7F85538C04C0F8D6EBA9C83E000F49BCC45D94A00CBBFBC
+ C7847A5E3A3ABAEAA7806DC5CCCED114DEBBD06E4F4035C7315AD1CCD71216B4
+ 8C7132380ADA3877496B3150CDC80D5BB21F6BC0DD6A426F5A752BA753E8A858
+ 090E68060A49A614D376023781F084EE968B3AFAE998812B495FCC38C10E801C
+ 665CE0F3FA69F4352E441D330AD94E59508AA07F97DD7E7B8C83F91998F8BE3A
+ 25CBB20954F09334384ADA28F449ED2A0F8450F11C42880A32B750B378A4214F
+ ED86BF2FA20D1EFBC91C1BF45C79A2B9504CED6CA6B51625241122092446088B
+ 521FC6C37F6E4AF9403640415DF1578FA1B0FA0C1E7B88F4478C683F156E935D
+ 59DC87B35465AE7BC6B2CBF837CBB7D6150A9A6D174A8E5F53897BF6279CC2B6
+ 99555EEBE505D1FB8A46808FC3E7547D8F3AB1FF3A892175603AC7996656F0C3
+ 67F2C343810E5AE520802575A0CF2FDC62F2FE725678A8BBEE0E19736C62BD2A
+ 7854CD94DC84B37F35C7DA901DEDBF4A8853DBFD33E5BB335CF73257F86733D8
+ 2C50A4D1E459E9877598EE8C31FD1A36D9B93316CDC48B04ED0F6ED5592EAC52
+ 6E0711C97C3DFDD3441E95F846735F25B6F8C78DB9DA5B0F311F37C35B0B4BAD
+ C1B51AD0665391D1D85612CD2CDD3FD024D6359E8CE8F2E7A480020B3094131B
+ 5487391D219E1BB34D995000B9BDA33C7940B0969BC721AD6A57ED686701993E
+ C6648DA477155EFAAFB55236FAB8BFD0EADF70F94610CA0C757578829709F43E
+ 0D1CD0C45D02BE8B67709AAF9C0384A2AE393AE29810B4EC507913D44FC82F9B
+ 6E22C208AEC4BF51C647801F3F6E0C2BC439DEA72839D54C451DF765AAF26BEB
+ 5A09C32E619C19E8D57245E78EC67206E02FD5B01FE57BC914BB86E3AFAB5FCD
+ 8D91E95D361BD7A945CC6D519ED32318B88230BBC12AC6C4616DB730A3B420CB
+ 5A17F50862BCB58D54AA7F2688A5ED4FE4DBD55F7666272E9D390F23D5CEE435
+ CAC4C8B93BD80CFF52A08E0FBAB3DF298EAF59D713020D39F44AC0CE38BA9E2F
+ 19F438AC89020645C19C2FE34566C7B488A9C4E9831C8317B64F6B03D7971CF6
+ 2B7B5D904C3A41556070FEF518CB8FC1EBB27EE0C6DF665D3D9EB7DCC3130D0A
+ 7CBFF72F9E79F5DD3540B2B07030B63BF23FA47715EEB43DC3BB609C2BF1FB9C
+ 4D70AD0316D6D42B0929F6AA9640F96D4F7775DD81E3A10D87A6C2D8792E7309
+ 06F7E940481C8C13C0BFE94BFE4F18EE0AE6C3914DBFB095DE37349E4CBDA56E
+ 7607CDBC349ED671D5A647E707071F0B3281B2D6EA45B4D0514D202E2D5CDAF2
+ 723A36EA96FF402220ABB304A6057D4DA19B873313D97AD5CB4BD87EC5392C6A
+ 115B16AB0F187AB6C148AC4FBA3E0C6AA80DAB86990F3D31CF23D491C6E2A94F
+ 854902B0B1CF42A8A6E1494396CCBEDE0CAB44DCF598C72BFA26F5FA7D95E166
+ 8A98CD91D041101EFA408FF6D62302B29EF723FB593C92FEB8FB295871CB8FC7
+ 34404A665CE0A622BB2A6C7D8EDC45902BCDF2E3CB5DE40424E1B9E872C04BD0
+ EAD8A290B5D059C2AB5DD93A2870593A6ABF5BB0CAA56DE883CFEFFB2D8A7C7E
+ 84554AA2A1C3C8EF9DEA1E9B3082489D2400DFF2CD13000A7ABD2959E8916706
+ 0427FFBA80453A860FABC39CBDDC632637C53E6821E79B36C3DC4980266FECBA
+ 13CBCD18E864C65F7B2669AA5D0C81E40190D29069A3D0BEA22494BE4DB8045A
+ 5BFF397557B5F37037CFA32DB7DABDECBE1A664FED7B4C6E12716C1DAB96EBA0
+ 70B76581766040C32EBEDFCEE1F56BAAACA5E9EBC6CF852044A9FF1420E541C5
+ 7DCD173CC704D17DAF151443483532C2DCEF154299524B53236D2CF107436258
+ 028C44F98A2B117FA6C2F30CCC09CBD1AC62A553352B4D5F0039A90C4316FD4E
+ 1358B2674F9CB9523590F0B5598AACB8FDB392B8AC61B23D39C0C4477AA7F009
+ 9525F2CB35D4BEA4E4A985CB21F656C716C20E80255BC64CCA3CC8377206590C
+ A420CBB0625A5C4FD4BA21072EDDD4224FC6E97DA1AE87F176F6793521053D91
+ F718F59EA28D14D730CE181D331CFCEEA14239FC5294DCD357AC08B7FB1D5E6C
+ 1B4D4A0B01D5AD7C816FC6043D716273F2D56BA62586BE6B557246FD8E0F6AB7
+ DEC1025651E06A65DF17A74E327CB16B32A0BFEA832B554E6CB47A56A2B9C069
+ E5C399C148639323C25333F57877CE9E1DAEEF3D77C65B452B2E85E889F89B9C
+ DD63FF29A9399D5AE5B506E78AD3E33EEBF67110D36C926B0305EF7C320D2E4D
+ 5D7A16FDDA49035D2211EF013865486330F2CC95D0F2C488D4B4954892F6D00B
+ F3345E5BD98276F0B00E257AB0B4770C735BDE9CA14850FD9C20F3B507E45490
+ FD7A8CB51B02A24D9F7AE897B9DABFA4CDC9C01951F8CE896BB12239055B414B
+ 0DFFCDB1F45B76A0AAD3ABE647B654562BBE72A8A297DD1CD4D75798568BF3BC
+ 9B1528FCC2A2123ED7069ACAB89981033D37F5BE4FD81CE5F0F75E3BC1F2709D
+ 279F5B8468F91DED59B3D694744167C0B106A83C24EE91B937AC34D213FFA00C
+ C56CE82CC55074132CF409D89B417B2D2277FF50F35A3F4CE0528A48D573CA78
+ BAB6901D3018E21C596279A3F83E72A622E9D163509BA641DB91F84424F2A365
+ F9161C0674EECD8E84028DD1C10F84422A2172F24B0ED9332E66092C368B9F32
+ 4128D263E82854A9E4BED7962963F264FEDA98BA7A54A720D3ED1AD40052FC01
+ C5ABEAF419D8296092347569BBE581ED79AF630324DB76C10C7BAC968B2AB848
+ 451431238F54EB745D85328A7084CA4B607F151FB568BF03444B867CB4FD219F
+ BB771644619A95779C8D3A0C05E882BB05FF7805AC8054E48DD278755BB98D12
+ 12D49AA87E586197199837DF7E84F784481CEA9B6141240CEE315102E8EA836D
+ A8CA8607253522AD474B54D829C13AE9F3F3CA56C2F5A383E635ADC0B4831368
+ 0BDCD6ECB40D4D191934747650C362651889AC4223EE52765A5BC2B23CB9D684
+ D201BF9F50A3A57D260BE6CD06DAA72555B5CB5FD863066B8E39ADEE699D2BEF
+ C60E3511FD0EEC10A8174CFF5E95101AD33C569743FC24C1D737B8DFE275C856
+ EAEFAC70902FDC4D16FF7C933F0F2387FD968C700E5EFC5595D67F2623E7E76E
+ E4036951A32312633896122A41E231E974E3C92067843AC6018258B964C47EC8
+ 6913266745B640D430C5B3FB103439AD2A9188DB624C0491BE47006F12747E57
+ 962D7CDBA7F817168283EF68DC1609A273857A5ABBE281C27DDB9D941329B91B
+ FAC4A25DC32287A7C196C52FDF09F5CD85AE39917FE5AC85B788845F53C91DC3
+ 0E93865A370F6E49675F3CC876E5A6C4CE8D185E5934A2B236A6F18112C95517
+ 75DFA754E07C5C47CFE7B28A3E94AACF4F358DC0450276EC056297A1EE974173
+ 9D3AAC36364A0D8E941576BE39D19BF3B2796802CBCF56448A0739CE2D49276A
+ F82DAEFB7FFD6D3CF1D1B9AE76090531D978068B737FDEA49DDF17E6AB7AB32B
+ 3F5EF71928CF664E3A954C45337CCB7A2AE8E3A029DB94F36D29913ADE24C887
+ C2D0AF73A21629CB3A3B6C2BEA6B1C274F83F5AFD7A6E54B03297971A58FD8C2
+ 463DF79CB5AC5A720BCC3B39551EC05D464708A3FCDC3F9E2B46FFA25BCC5772
+ B74E27ADAC70EA7D319D500D5531A9C6E608AE5A6D8722972FAF3BEEC59A7B7A
+ 63AFE181A09430B16C0711D5177F9CB102C04DE48BAC8290C206BC8060A4E234
+ 72BB9F75059C040BA1BDB419683994CFD5F8AD4EFC09688680D4FDE707931ECA
+ 7FBA9EE94D48507752DD27B0E887A74F256AC83F96FC1FE249610D20B6945579
+ 46E6F6E54B4CCB80A08306AF350FD53DA0C80C8D9E3F308D737E91AA00571174
+ F9AFB8F82940DC35BA9870DE3071FECA8B2B5E1C5462C782B060F1EC86C7A8BA
+ 93019C356008C8A9FA0C8C7F42A17525BB42C3360725EB1CA2689AD7513B2B0B
+ B729C9E45AFD9B7192473B0EE3066C570BC972FAE9620EF23B6C21D63856A6BB
+ F9BDB2F34B6D6F67E0303C1CC6CC2B65E01BE544CE74B08225C929C6CC8D5EB5
+ 6A1F51EC5053DDDB783A5F9B40148D60D14B9A6F2827630AA27C42596E75EC23
+ 12F94D6D258DBE1CEF9C484C2942C9A55012AD1F1554F9C1BA56CF8BA6FBD34F
+ DBFFE85D912DB3112580F54C3D0FCDFD471D65787FC91D9E108C98BA5F42DB04
+ D8BFB40826798691A4D59EE800755EBD27E29D5EC89A398AAF7CF60008B0C8D1
+ 3DAC1503F10C2A4D35642F69B7AA7B8E2499DC1729B748FD48993D97944A375E
+ 56634ABCF3BE544896E054717380AA52A2BBE1F033D142FD0B5AD54073C37C55
+ 9FAB88A31E131063E3EBDEF51D8B6630727EAAB23B61BFB181E901540B0DE9F9
+ 107444E0A64BEA33C887D59FA18939021C207F1EB14416A0A82C674DC12143B2
+ 404B03590BC345837891085624655142D413A1F4D33DDA867DD6C911E50BCA29
+ A8E27842731DD469875A1B3D43DBDC5B9A88C56D7A2D11AC2F4912BE29AD407A
+ 7540BAE2F79220B4E0793655804868D74F96688DA2BCBA1180B25768881D1CED
+ 0AB008BCBE46CA592F1B148067C8F65DB1AFE00D02332F965AECACAD64403439
+ 353C284DBFB7772D2196327CC61FBDB8F46460FD8FBF07C846DD464F28276995
+ A8BC90CD6E727FC7A62F748592AE5A0759CEFE26DE3214F3667B496401627837
+ DFA948096F331C18F8677F06473CC09DE8DA9C781E4CC296991D938106F94EC5
+ C969952F4C20C9E2FC339C522460D6BE7803C741AA446FFEF306EA994480E444
+ CE88088A20D4350674CD2E21539A423681618F2BA3685DAAD8E118C4D218F1AC
+ 16375D82898ED4B7784ABCA431301434BDF7BDE47F691C594074B63689187CFD
+ 472A6DC5EEAB02D9D87293BE4C4ACDC30C1CC0E1AFC1A8A357A44159512DDF04
+ 3A1EF9AE85D4228A75C27C2424EADAB56822473B11F35BEFCDC4CD62E935A8CE
+ BAE9A59C269360DEBC4281A2A7B91CFD98B771D7E7AC8A23C7887E80010207EB
+ 27E139F5FDD625213D04B4AF92C381FA0EDBAE2B7A5D377C7DEE182EF9C20FA7
+ 4BB2CFDBD40EC4DE4AFE859986CAC697C263C595FB90C896E37BC7D40A582484
+ 99D019760FFEC78EEADBBC5105E1CBEFC0B4F8249C843C23B0A8C5C9E394231A
+ D60B29B79B262CC6EE152A528F3D65D076431F1D2D5C1F9B82FE1D71EB4ACA9C
+ 1989BE0519ABE081CD11F95A1D60DBFD64A0DE51F8186EC7A89BE9C6EB9A9064
+ 2829BBE5575366FE83F3BFFB5CF760117E4EA21C0CD857BB4F0CA045AF3609C2
+ 0F8188BCD18761836A5437B42A764B5E21E40994CF369A8A84B2B851366E24AF
+ 3F0E2A46D380149E9A19E8ED0887ACC0AA7E62FDD8E6192DEEAA3C363588FD4F
+ 0954F098FA3D5824E320AFC9FE55F21CB7DC8E5A39B30770753AC5D5F080DEED
+ 6347AA90D7C33A79554BAD0EF324D79BAB08FBBDFF674B4579DD639B0CAC1ACA
+ 4A2D4990378ADBBB22771623AD5E037948D27C63AD9A4B3C7855869B4A947A34
+ E43221E833869A2B08D23249C3973FFBBE1B996FFD5F1CBB1331000F1104E908
+ 5835B43A22C491B505916FFFD6B80C63593E7AB3B9B09D2F0FD869CBA19B51CF
+ 78E438409C2A0541BF11D87787781307F1623B0504909608475D8DA16F4B5B53
+ DC9733C67B0F7959FFEA0906A83D773CFAF539784B8DB34AD71A09F84EB28C06
+ D881F3A28B5AFEE47B1CDEE063B424B7C8782DB091C4016B2319A1A168D5A965
+ 09D4B1274BFEA67B3802047F7C5F53B420FD47E6DF344488F2D9591B852E6922
+ 7ED3EDBC851E4111A19F88DA5AC2E9C19E123A5A30B9E60C2EEB163FD66EB17D
+ 8A41257BDB90A9B53004F50DD6CB45EA97E3DD2BC6CCE285DB04648D8FE0659F
+ 9433363B5635A545558F175E0858A947DBDF94F6FE43228294C039F39951A732
+ 18C8F1EB94D3551813080C2AB49F84D0510C5516ED52D7A987520BB4A7E037FC
+ FEDB1965BEE81461A2FAAC2C8E67C692ACAFAD12C0D036ECCFEBD35582048823
+ 41E767A95D956F1DB6486A109484979986A40E1F66EADC602EDD4E91B3CF68CA
+ 9D3B36FCDC6989A40F0689DB06C9ABC7B953AE56377DDBB0832D5359DDF78E78
+ 2B46E684A751A58ED2B034D40FDE50F21C6D5BB0154F9ABF491620AE43A55D06
+ 062BCFD01AFE91851655BA5C519AA7F866BD92C9FC1D5BA73D826A2EDA71DB0D
+ 8FEA4ABBE12D0E412E82C775FA4DC62943D426471BC11FB0971AB47093DD98DE
+ E4A7C05ED6B922F7DC720C01F1CEBB6AA9B76C83580DFBAF96C84A8DC2112EAE
+ 81F706B06223677E71ED737B8A0916E1C06DA5CCAC0AE5FC30B086033ED65ACC
+ 1FA8463863F778F0DB50CB3A5373D674933E9C53C22628391AC018AF2F70E514
+ 0F94FBB676B88334EE6D9D5D6627DFA7F804CDE488CEF0393472D4566812A433
+ 90892F435464E7281EA2668ADC0CC9AC8204ACC1E8A82D0DE8035D51FD861EC4
+ A5A73980B92FC2F89FB426E6320C74F385DE97A89AA3B60C4674AF0141E3CC9E
+ 53B7C04F1FC407383AA2255C0BC0D2D761C76BF989E9F73EB42A86BF091CA4FE
+ 7BA378C6074F5610A9AB8553590C872DD4B06E0AB2B72AC26AF0D6CF069C76E5
+ 4C085E7787264CB076328689216012B61D6BE0719838AC97FD463CABE92A2CD1
+ 5723ED1F45C35EB8BF9B53A0BBC660D0997036BF726CBCFA70AA92D6882AFBF0
+ 926767B09B22FB76FB98CB130FAF860048E871817B6ED6DF26450B35377D2A0D
+ 032D1BC919366F8FC73E3300D23F9B3248BA9DE1A662E3A813ADAC64B2D9D447
+ DDD976B7987DEFCF123770802F8A51F053B8052654633F62CF8130D3A5C64712
+ 891751E0B8A4932D3C96193880DAD47C241356DB1D00C27C759495FDB68F0D7D
+ EF4E13C7E7B05E2A7177D33390482BB70F6FDCB91306B04B546F1552EF60F1EB
+ 7E38CBB26AC43119023F4EA7D27379E7BA63C75D5B030DE07230461DF99B87E0
+ 458EC644EE081D8DA094232560F5C5C82A2738DFCB2DFB1308F4FC6BC7328DC1
+ 78C56B15B54514842E4B4FE510103EC82A2C01B7A1D9E55A09F24A00CCB4D2DA
+ AF59645BA816FAE844ADF976873832AA9E9531294F07883C07B3CC8C2DDB5E9F
+ 376ED661DCB29FE6A16F39C6D2015794686A445CF3D199E5575855FF96A970AD
+ 770163F3B7D51752AB9714CE45373A49AC7DA69B431EBE454F6A03E2899B1A5F
+ 4453C1461F772B42598CD4798A629123504269A3D05748F35A5C8D00729E7D77
+ E8D56F3306D2761C7ECE006547A4E2F68D280AAD75C1933094C600E37FF066B6
+ 7A2135A0BF6AFBF1F7177225247CBAC9613B517E0EEE5072E13E1B009E741C37
+ C382F32EFBBD1A06E289040B0C85217D4AAFCFABFFF243A68E66A349A1AC7A4D
+ 042179A3B306229C7536F5A5D33A80766F5F876A5C661AADEA026CCFBDBA9006
+ 448A623211365CCCA37270BFDABCC176E4A5EA1304279A88CE911B094AD39B82
+ 079B99ACD88BA450FF30E0AEE132DA10F9172BA5C7E048DA733DD9E10BFE3124
+ 00B5380B5D532D3FFBFC2336D3E29BA31428273E6BA7856AA6230BE0EAA2C52F
+ C22E49670DD3A729129711E52D9CE911C3485F21D64075C683199B05859D8FB3
+ 8AEA45ECA75B4F5018CFF073FC65D36D22DC10D77E337F3A6BCDF51ECB4AAB16
+ B366CF2C1DDA4807CD150D526281ED2B4302C235027874A4FD0CCCCA048EE706
+ 3018B4220D39FB64739FF5F66336940E83999F1F26CCC6EE8AF09A024E498203
+ EAF86DB981518EDC7A2F6083C5E3F9F6290FE68ADB22CA6783269CCA36AB5CEB
+ 432F70BDA27F10C6C22BFC2963250EC836026BAA4FC39125B199210E2A3599AF
+ 9C1D6123D4E20C575CBA61A42D9BEE4EE82B6393C8222FE0CE69A2DFE87EDE6A
+ DC58A924FD66B166CAA71EBDC6F845859792C128CAC493BAE3DEB4139385A5D1
+ 2045C8FF34A751D95C77DB8F6F4C2C5BCB19C6130381C35A016D02B67306532E
+ 85D621D1A6CCBD0932FE1C746BCD79E2202087BCCF86470F857963E530E2F2A0
+ 7A2DF0DC3AE016135EE86E30F90C61FE45C13D38AEF3F4B091621216268ADAE5
+ 2E1157CDC4848E763929DF68650D91AD487D648E79637B07BBB9852592D7FA1F
+ EB079E1F7D3F73EB3E4FD63D03342E984411086AB89337BB2E797903C37E23D6
+ 8FE8CCC45D36B3B412A63B98868A7ECF05B2EF279CC6A4DC0BD4804A3FA8B394
+ 4EC7EB7D8E77C8CD3882BC377C98F349171AF64B86DAC0914661739687072085
+ 375DE236B566802F5240A23C14ECFFD87143DE9429B35AAE04E7268C39C674B6
+ B68F7AAC3E802CDDFBBD05306E85FA7682A846B3D3FA8753CA2CD4C3FFEF0BFC
+ 4A7C43E154906FAFA61A2FB5FCD2DFE6862F41F95FAD9D39122A095BA2EF2CC6
+ 888B5728034C837EAEB2447EF7CEAAFAE6EACA010C96EA825E605B0606BB5664
+ F65859955707C46441C28FACC1B99040F936F460461722BCB7D6393E89EDBDC8
+ 3D666953B1581F84E0D80B95514A6658AB77F31B64A1B3A455A1AEC5D091FDE7
+ 19FCD88F56291CA1C7891C29B2BD235EF6667E9D89F79BE0611FBA61EF099A3C
+ 6B92687B64E33BBD0FE66D7CDCE6AE5ACA787F0E350AD5B014198E55DC506E07
+ 76E3F80191B5042BDB912762A98D2E5AF12C31F491CD01CE6346862C724383F1
+ DCD028C4595E24D90D95A4820F0D5610DD3C7BD76D06F5BE16EFDFC2A71152DF
+ 1EEE1DAAE7E6712AC4BE9C04EBF6517B6DEE63D769992339F5F551C59816D41D
+ E77979B8FB5BBC88EC2CA1FAC5C1A7BE28BF65CC967BC02B05DFD07DB61F4ABB
+ EC5E421BCC65A73F216B0D2DCB69F581F810EBA2D724D21A49C6CE76ACD7B78A
+ 03A5B99190BADAE16FEBAA7C4956ADAAE0E06E7059BE4045120E13CBA4240F83
+ 73471905652086C39398BACE097F36209C30335240BCB233E0115507FD9CB40D
+ 9768353F2C55D27261215D3B4C0A10BCBC53F09788F5037A9AC50859CC1F107B
+ 7D52610E30F21EBC463D33F460AEF1D75E9B6A2734E66090EA3977899D29F34F
+ 2295AC7960A1CCC9B975F445C9CB9AE5E84C706D99B9A6640489A78DBCD7F6F8
+ F47B8FB7F55E3C8EFFD52EB5F596148E66525D204AB58133BBF22911D3C140FA
+ 7BF7C5D6E2DC1918095817AD6DCC50BF275DBD93433E3226D564A0E67B3C18FD
+ 5808F3AF56AA2B463161216856426171E6894AA79C40DCF4DFDE0E5A75C74CE2
+ B62275AA27710EC6AFA8599DADD4D7E3C81B0F04FC3857861B453F40BACEC16E
+ 86D54F31B2A3EADA7A9CE2D18666132B8492A5A4C5D02D207D7E849C8AEBD567
+ 6F1BD66C67AC3BEC91B89896A73A9A7A10E9F31F6E779078337DF1F07A20418E
+ E95AFE32D8D960145E667C2BF40A681B104EA07BA371C0654FEE662E65B95039
+ 1E6CC8F00194205B57BC3C789B91C34B0AF5A378CB75A7CD48C620D392C76E8E
+ 794BB915DA16F79218AB0301D43BFCB91ECBC455170F0AE1CB4BE0F00FCFC133
+ 1BC0CA352ED0457F79910006E42DD68354317EB6BBB673B9B61D15F62FDC2F06
+ F9E16D30A9409E2D53B52F209A2ACD0B452547D2C9DC892AD13FB0D06FCFF33B
+ 73A9163E37A58C3F8DFF380B1590B9D15B53A04956C67FF1913EE80C16378045
+ ACBB2E57904D6FC09705B27ABE3BA548F20A08636ED6F4C9DD146CE4CCF79DF1
+ 3138723CAB34723B88475CB6005BBE0FFE0C951233CFFAF2D31EA8A17F1DAD67
+ 979A2A295F4870B366E4DE409142BAD9B794240BEDBB5B7B17CC881FB8A7C302
+ 35281318FB93E82C058D66574BAACCA3B0CE5A267ADB2B716F782987C567DDE0
+ 0E9A7D5AF211D8227436EFE3B1AF8A3A3200EA030438696AD50D572A773C6809
+ 044939C428F9AED64BD25E86391E7032D6B251AA28320F9058106505DD49BF13
+ 20E665494F5553789921D0453A1C701090083ED2D7D4D84DFA4A972241DF60AF
+ D28F8BA7034AD0E47F73ECD13DD99CF0C804FA756E0C45CF7F3737B046D380ED
+ 58A4194B97383A1FEE78B356DC6A4761DBAD5C27883E1EE374AF76656BFACF2F
+ 02DE4BF8CF77BE34204FF7487C3BC3C69696313E510D4C6C660A1FAD8B5F8115
+ 9909DEA761E1B1CBD56DC8B738D6BD2B7869A574B17A5CA6DBB63B35BBD53894
+ 58F27A703EEA3604BC08706A81A7BDFF23CC3ACFCE708492998B3B617313C8E5
+ B57B1E38A620211459C0C6E6A656A606C12B150C664290FA1F9DC3B5B4140C14
+ CDA67A8711026D3D2993E224132A0C83B2BF0C492FF5B08EED39325A63DA5DB0
+ AA57427B0889818E76AC6168EFBA1E920C785B67E11017AF39EED759C44A47D1
+ 92FFD4A7BD4289C94117B0B237B9277F7143AE814178F90589254FCCBDC69D54
+ 9EB152C2614056843BC44D082BA4C409AA6232426C97234752B3F02D8F015C51
+ 7885C3F8B34310006174718DFD699F2CE182166619BDF058F5B7E6C60BB2600E
+ 40F97429B56BDBD0EBC153D9223618D9BFD29E858BF3F9B10C2266CF27C5A079
+ 32228F526F936DABABC61B52184AB363F1E25D0ACA9391301E35F9EF86E3289B
+ 39AFEE8F6EC61F0E1AC584779B0299C9D1D35CCFA5FEFD392A206FC17B606277
+ 37D71880C92E1642747BFADAD824FC2586B9A0D17631B1DF42C75F5730D5252E
+ 1A38447BD53E03CD98A523AE78E275352B330C6E2FEFF2ADC5971E0940DFC723
+ 408277449FA4B72880FAB1E8E15054987E2F03C9DE44987156301AF17F12E904
+ CC8C6601AC2D0B1427FB21C5F503FF71C50AB3F305DD988277FE68AAD4DF6205
+ 0EFC7CB341C91D85A3AD6BD885E7AE7D66973B12F01CD9A474B60B9A83DC6518
+ 29456C2D3A65D9E9C07B556E04E9017BAB70C034B3A547BB8E3A94B7AE9CBE68
+ 78B2E7D18082355D8A6CCC55F1BACB26AB529090AD8FA49A4B591E4EC7EE871F
+ 09237221F745F2204CBDACC671FCDFD43FA2E9B4B1ACEC3263181606ED22011C
+ AB2B23369B31EAA2A6D17540CE250C30F01826EB1B0FB572A4ADAE5CEDE1D1B4
+ 4E86BC5632BEBA468D8BC1A9918D93945EF7191CC1BB68816D3C10A77CE59F4B
+ C291C9A13E57B704564501EC210CF27BADFB603B019AE90170A3A8C47D703FC3
+ DC4A73D9CC9BB16E6D4315A76448436068A61EA84972665F80C4E5CBCAD104C9
+ 6AA32FA73225C3C0AEF2CD77918DF0F3C549FF7B198FDEC2EC1908C9810976E0
+ 2BF522A12FC5418A5FF42542C737B4191007A5AC18B7E511042FADD6A5ED3320
+ B1F37D07CDA30042B6BC9D955CE336A6301FC05116E9E13ABF6DA2148AAB6028
+ 5B0AFBE6B6FDA2558728A02D493CF68673343E4A79EF630B19FA6E02D8646D0B
+ 44A35B315D93BEC5F6447256335ADAC9F2BEE7BBFC6D5F3267ED63C9F9F69969
+ 459B6140C75C4044B002C6BFD8E2157810F1927A52F079447714C5A77472120D
+ 5D82ABE9B1B175B2484D669DC38C9BD9ED7A296724C3F784BC1CE25167978636
+ 07AF10569F798D12B5DA37634BCE16D96F99222E6205A9E2CFD5575411D069C1
+ 57DF0493B2EDDA152EBD3836876331885F214061086A540881E770850C650360
+ B82A7D2FB2AD5465A7ECA0AF2BB93A0E9359E5C8E2C3FDEDA93325F9C8DA5DA0
+ 84CC12DF00B210E2DED0BE1CAD81B7D86CCF1E23D4BD65DA1E0F69DBF5BA19F4
+ 8EAEFE059CBF0E4F4C18C30E3419D746F6EE3A74D587457BA9A9F69930E48C07
+ DDDA7FA781313A53CAAF5942C8EF6BB02E4BCF8B37F966045810AC4EB6DECCB2
+ 3B55969A9BEBC2E67F2E747648E33BBDE575B31115DC526CD87500829B6B3D71
+ D5389B86C6F0554AC67D1183D77801FB1F685EDD3B95AACF1D88C74F10553791
+ B9980D27E54E047DBDC42DC6F9B37646DD86BE407D047C7EE48B9FD158431E01
+ 1EE68C465CAD17AF471072594F192481EAD58287C3CBD5E711917742BC0117D5
+ D5BD50E9A3610AB3FADB0230BD18E53AAAEE71ED3740BDEC37E4D4C6AC1722B0
+ 92607F0DB2631E4465FB341AAF8A49E304D8CF2D0456079A5FCEE9ED5C866989
+ E4A9783A08945A68844477F408E91FDB60AAF1DD8F3E1090EC6AE29E48B6E907
+ 3DEA2D73BAD1DE1B1E934F4648C0224DC68993BDC5DF04E216FA976A0DEC8FD2
+ 76893BE1391F164DD6B3BE8E6646921A8A8E32345D28BB29A7259B5330CE317D
+ E3841CBE2EAB7B0559115F51D9A47C75CA66FC11EAF82D5651D629093A249FB1
+ 145B5D4494531C05FBA01AF01724A0047720BD7A28F8CAB5F4740C85BD9C8C53
+ E9B9E50A013AE3F22BA4FF8D0BEF73E1DBBC5D91B17CF26A6B40A6CDD912ABFB
+ EC7A6BCD147A65AE5DEB76B3224D19C063DE31D85B13231EBEE598A12DA43629
+ 3476F2D4674CD10095B0CF0B1998CB2D9800634E176130833CB4E41BABE51EC1
+ 3E719FDC535972C7A4BA66DB02C42FA3BD13021378230C168CB5C0A99F56DA1F
+ 012B781A90A893B8E24388F4726E41106C77484DE00F90291FD1CBE480263C0D
+ 4CE0F1DC5765C72142E6083369D490567258805BDDC75FB518BBBE744C1B08B0
+ 43CE9A97FE204D4AD2EE9338B9BC9DA9816EB6F13281A82D33C3B47889EA874F
+ 6FE4E71FECF8D353309DB7ACE9C2FDE933D159CBEC2E4931751EC7B6A74BC869
+ 7378CB941521907754AE00D1A45099C953FB6DB514B5BECD1AD04FBD32C63E51
+ 867E4A6271AC756ACF3D7D5E8201584640BB465094BBE54525DA8889FF5BF4C4
+ 8972144EAA4FE788E97AE16699E929835612C1B426568730B4239BD820235684
+ 4C6342CBFBD98B248F8562BABBF1E47B2DB931A498B2B02FE095BE5724B70D7F
+ 17BF7338D0447B51FE77BBA47C651879792AC3CA0849D0582A4243E3325580F8
+ EA2F3380942F0982F3A8FE56EBA4B0315CF5DA02B759D1FA4EFF8C322268BAB7
+ 5FAEE7A7036262DBD90F47724575FD8CA683AC8E7AC6125B489ACF078705DA93
+ 081B573A4123B318249D6BE07B60483F663C5FBA5943EAA4435F8D4799D04768
+ FEE029EDB429D8AB292B86B5609198E4FAC37A6D2A5C5617CD8BBA58146B65E4
+ F98B48B90B2B487A7E54F6EB92718AFF3C938F0CCAF7C8F3109F53AFEBCBDC95
+ 53D6643D9E48905678B31881A2B52C6C79CE84F14CEAAF1BAB8070E84D7A8350
+ CAECC1A8CF4FF093B83A67B455CDD881F23D74B88D8D8CC45D71A88594C091F5
+ 73E7B54999E44FE856A87FBD151A6EB74F0FA0CCF50C8E7CCD2FD7B26E44C7C0
+ 8C399E67B58CA92D7EBD517C0D59B15526B698960D815129E55AE3B084E8679D
+ C0B05BE7F95170F41CAD5C772A0D14A614D74D027FF0843D69A4505D899915CE
+ 31BF09A4E7D4CF2721BD784257B88A782F46AEF82C521EA9D95421BE925D09FB
+ 1A0E3DEE49616BBF9494A033E3FE016E3E6AF9BC522022CFB13790BBA97C44E5
+ 6D91196EA867ECEAC5B30DEEBA213E422AFD6A80E76B2708DB0DF3E287AE00A5
+ 5A589E6E6AB2E132D8101ED01A551657ED2A728137B39B868AA1F43A874972A9
+ AF2FE790BEFE3ECF7D6E61FD0DBCE3CB44ED3B55E2EED5110B0AFF3B316310CA
+ D50920130BCCDE42E08F2F3C9E0E33EC95C6F0610B6B3DD382130819901F951A
+ 77EE72F5F5578D0C1D9F8E1DF0575D2779AD24C7585404FCC203ED7E51977DE7
+ 30828FDDFC02CF6B68DDB8E505DBA555EA89A61006D769E99B636E6942CFCCB7
+ F5D56123E39017D37883C28B0F4896CA1B9DDC08C5461F9879295AC5E644FEDC
+ E749A96612720EF05FA7B2E88F7B5CE1D18FFFFDD91BEFA8AE341851A917A02C
+ B869E0E51691CEFBB6BB6EF86B526A36BA36B27AB544720398E6A812951B9673
+ DE207A603C3DD021041C2C04EA4FAEA6ECA0653B7F71CFB7AE96A552E2556F53
+ B8934537758543B15A05DDA83292BD48E53D330F005F789FEF48B7B98CED7287
+ 3CA89E14B6D6568A98D7EE690DFFEE6526DEBE96738CA37E8DDAAB685AE9A71D
+ 7227463BAE2F48A2D96CF3F922833DDA2440857CB15F7ABFC4DF3156CAFF9B40
+ 49E36A63A25396BC2CF2C894980B1FE127C4CA549076CDB725AEEC0300CBE926
+ 791C4926AFD31A95C6841517E144B5BE81C02F184B22AD90694040722B52AA31
+ 691FDB7A8BD727AD842BC451D1D4F80C28A5543A228BF68EBD3EC1E16EC4FBAC
+ 56E6A2E89A89D42936F74C7CE52CBEAB4CD42CAF32AC0D0CD1E3C1D26C8AC7E8
+ E1B3F781B6753A27B6844A98F08DCD816049965283CBADD692F4BE30D5C60DF7
+ 1B6908F4A46767F363D3B5D5C591EEEB63A232CBC9E09550927AD2C9E2051E71
+ CEB893CFFD95CA8F2C5A9D8AB8599FB6DE5E23E73E64BD6CE1E53DA5979FAD78
+ CFF71468FDD2EE9369DE8CD71E72E3643BBE13FF28F2D1E07117C816CEFA6F6A
+ 10F758C3FC2EAB34A871D2652ACC41B2B15827982547E2B2E754C23F9A9424E4
+ 3A99A11CED5752081C27E1A8E0D146E032D5F9E1B5B9B0D10D1E330A7A3A4821
+ 0765469046904F93CF03360C2C70130A38AA6521AC6B6D56C030F8569260DD7B
+ E74BDC0D2A3A9F3150FD40AD21895D921439A9E0122F5B1DE51DB79B501D5D8F
+ 1D2E313246666B0E9E01B4E1C44FFF3C5F8B560369A733E752E7E9B7C0C50670
+ 0B1137105151DD13DC5531EDC9143B1520C4E8EE71B662DD9DF1DD61E0474107
+ CD912E5761F215F09A44808E457D54B67A7B4557436B4218C472A0C0192AB15A
+ B706C18A59525503DE1CCD543D64418910225299AECDFE2BC6FC195EB5D06797
+ 9EB4D6552CCF989A551FC11324297CCCFA87CFB6B853395BA7FDD278CCEED65E
+ C1FFAF7095B81E62B06DF3CF439F3775E213C1006C30C3F2F0182BAB02BAFB82
+ 32A122E6E9562CE25173B06907E86B7CD48B06D909254B6B4025701D484402CD
+ D4600875140F6E4219D7E2F83E297390AF45A263A9058A72C0E0294BC613679C
+ 056AB3D7092148FBC84455BB2D2AE49E707302297BA2EA2D0E9D214ECE3CF912
+ E4CD5B37341B5A8E07BDD264A3762DC083F69472C44E95BB815A84BE3EB69819
+ 18CC114B9BB89EAD6DC4A666E83523C2204AA3D12888060ED013AEB554C70282
+ 45D9780D6FFDEBA85C4334564E4C1DC45142695C7E6D7DE15499A323675EB4B5
+ 3BBEE3B242DC7AB2493E700B798657D0EB6CADCAE3115995C34D37CE738B6E62
+ 2EA51A980C5EBDAFC71504DFA8BA89530B2CA718443319454731D0B07BC2705F
+ 8697A808EF034A63AF1786B3BBB172D006194ADEE7190F43558696FF6EC3F6DD
+ 5EB3B5660DAD5DBE2243F9404E84BF2999A14740F759128135A6F222FAC1D74E
+ 55C146BB51BFA13CFAEAC22250CCC7259AA90F5EFDB623F55613ED2D94FB71B3
+ 28189E27FFA3082A51C19F044F23D3BC2BCA4DD541C452675D5C6B76B3B13948
+ B380447E80C68115AC76689DCAF649488B9878C1F6976001DAFB50ADC2E887CD
+ 1C61BA9BE88BF3CFFE5CD34E3A848380F8C0753552C9B774C4A09AEAB0669D67
+ F894A60BEEFF2343A36021CC80141EE393202CB6CCC262A04BE4D3234CA9F77C
+ ED491EF6D642A94232C2F562A7E1C3E121D3092E9E6E7B957D06E8A32BAEFCFB
+ 580724EE47B21EC522D7D3B9649D12074537D4138E3BB8DB8DBBF68FC34FE73E
+ 97A7901EC3A24601A0208AF39894EE1E777B6B4B7F253A74ABD7379C61E79042
+ 1AC717685EE80C6AE9157B21492D3638E2F4098C504AB4A88749771EA3A3079B
+ 61FE94FBC1733D924F35F0D29694025A227513062FA7BEC1052C4660D6F228F8
+ 3D95D27E9EC976462B77F9E399CF51B4E301E8737A6700961C2874553C3B74D7
+ CEFF316B6C0EBEAD6272A381A6490440C4D41708A3F4506CB456E2B2BA2790C3
+ EACDD66E69B5D0B6FCD6127A00AF8990F4671747EA1BE633EE8D2260F423ECA1
+ F065172A5E15597D5410755F64713D4355B38919477AF585FBD45AF51E9399E5
+ B04FE7C101129FE6EB8B3DA549BD1330F031BAFF185BED4AFCF19BEE84B62C52
+ 9BB2824CDED69D0FE6E2FBCF0D8530E65F471E8FBBF8C9F27C37483FD182E7ED
+ D368B833E42755D6D6E1B6635620F679FE91D03D59C49919F6A55D626267DD72
+ CC2F504550F6F981AB012AED8F52BF32BEDEDB7E93CB60935027274D9E881BAD
+ 9EA88A2EAC9DCED200AD3E7C4B2DF7E0350FA81B9C3EF2671F1C7D6D7F8CC212
+ 17CB1AD95588E6411440FD86BD77AF8A2B76AF84E90FC445BCB5F291C60708B8
+ 83FB4C105E0730BB55002915BD0F6A37475A5ABF0DEED9766C7B01C9F9F1FB97
+ 016667B671E27B184255F166DD706E4A9E15CD17F9B3D437DB78DAFF1A59BC4C
+ 2697A48AEAD6450AAF7B1329EDA83EB22C9BD4E99BE13B03C223C7B1330026C4
+ F5081C3D89EF90D2AFCB74C795DD4A4D74A8BE564D87439134338F09A401F9AF
+ 97C67E68EB9214D88C33AA3751821CA2724B829C0B76B4B00FD747126D38FB9C
+ 438A19DC2FE3AB118BBE094C073B6807FA49DDC38B5FE5FF8CA614678C6CB899
+ 53A1B4AB5EFB004616041804D8E481441D37B85C95A122BA6505B5A7D870822B
+ 65CB2E9F84DA5EB4C9AC7A1544680A20D3A296731C7911499A10BE8791F36256
+ 619BB3B8FF74FA59F6CA9EA919532F50D8B6AAD67B113A3096AE5D7943890233
+ 268173631A7CBDCA2610DA2C806D4416945D48ABA3DE5526F13C3B12A1F71FE5
+ FB3DEED8B537854440DEA3066D784B2256E3B045F03F3DF1670825ED4518ECF4
+ 355FB19AAB338D8802A4AE94C82903484D47AFA7AD94B7C68354DF4ECDC218C9
+ 9C5CBFF9F7E5657AA60FDF27AAD94E6788918D353DF03418161B9603C83E3A3A
+ 2819C17355AF45B5867A0CAB005B3E4A2A76E511C96D579FD0FEB976F64EB7EB
+ D451840C3F1F04C686B1EC4E10F163ADBD0822327191E905523F131DFC8F7D13
+ F5876A0B4B35402863572C119102EFF5A77B993E38EE6352C3477E4C2BFD7A35
+ 4FF7EA1DCB0C0B8BD0B35290D75D3CADCF0C8694F6115339753890D0F4D06525
+ C7425B7C4A067C8EAEEC7AAD619CD4B17BCEF426ED0A372C12EF3A0395C7F420
+ 9E0ADB6AA214AB9048C824422D504DD2424D0FE6C5F117D8CC18713FEA1C4CFC
+ 877CEFCD19888E745DC690F15BCE31A93C4DAA93D7748F48247D08D4F24BB915
+ DC40CD9748BE6DC864D8A300BBE96541540272E2A10EEBEE2A99480A3BD8E801
+ 82FF8C6258954543A1842BB651F3A732126835DA782F7A4F22748E1733C27204
+ 736FBAF1718786A767E3C33BB55252F204AE8C5412D1496989A1D340E0F9DEC6
+ F26D88383D8D8A8A6AC1178740DA44216044BC06241DA5608F8A4FCBFCFB7FAA
+ 083A62EB381D80CDF0F74C8582C01B4356E3BA50FA11C84D9861D079D0955021
+ B6E8E8707EDA91C9884F3D0F28F8F55671D26EFE54D439A51E232B19B7EB3E4F
+ B422FE499CF567CFD7D3BC048113C8D68238065ADE04AEFF67534FB84C3C9CDB
+ 00A28235FE9645C03A045B30CC12EF2CA6A23897AFD6F95E8A0049A3B3853277
+ 7553CD0AE1CB7F02465E48949ADE479AB6EE5634EB4DF718E72E33756CCD1B11
+ CB0549F7C381765606C9F67E838AA52AA834B5EF8D5C83F896C315F0E07ECDD5
+ F796265E2B2B7FFE897DE63FCFA90CDADAF3F5485B101F28A7F12C95A186DAD3
+ 7FE8B1F81C48C7C96471C40CC9149BB1BF4804FBE4CEB5ECDF1B7C0526BBA75A
+ AC92F0E806962137CFAB6070C1277399D35B1BFC7FA87A2E45E1CCFD019BD940
+ AA784F92536367A565DA87609EF64B2D62973DB97BB8726FB12E0BDAD088D585
+ 247CF0E1927E86B7528C23E9DDF6B09DCE8BFEB00D9A80BD72D7723127FCBEA7
+ EF2453340B92ECC181710CA2B567F147C816812AD6A8BDF9E92E4E6A7C3E1409
+ B228B7AFA83D07A557C7FEA6F02060D3A756B5AF0B0670A80D3D53F283450F36
+ 3440586F736A79F4F53CEF576857882560A4328056B015A07A2F3A8E9B51437A
+ B0100CEE2C33EAA9700D38E87B258AFB6301F191E89DAF94A1B9B45A1644FDF0
+ 8BFCE93192E7DC9DFA442FEC1F70281C90D660294F7D7BE0294759A51367A6B0
+ 7AC6AE5C0E6BEE2BCBEC1FAB26665F550BA90332A14DFCE7D417FFEB0B32B410
+ D889B7BD6BCBC11BF440DAD16C61A23AA3DC66B89FC87D8F46F5C3730B3715D0
+ F72EA0FD83CDC7316A86C29D3B387CC1EF4FF946A1CA97856A4A1A4108F59ADB
+ ED76CC324B3CEC290731B4EB84B5CBB387339436D86B3292FCD7DEBF0C9BE075
+ C3428150D1835A732DDC0CD4D388940CC306729E54BB765826E098DD013A4255
+ B1E1E963699AA1211507FD8D06626E483CDBDE11A0E4373F25757BA391B7B47B
+ 4828E3B802D25F68EB2EBCAECB7D90F78D3D7DDE5B78DCD996FFAC9A936BDD12
+ 4FE7A9F027ABB30683DEE6559ECED6E01F18EFCCC7AF89A4342F5A227A448C2A
+ A7242371B7EC393FB98AB146B66D5BCF219AEC1890AC6784B5D1154FCEA5A0B8
+ 031AA33B6FECEF9C0A8D3A9B2E50881DA0AE2157B8476AC4DAC420688C954056
+ 4B62663E069953B4FB25F27FAEB473C65B376E4757FABCCE2ED5CFFD2914CAE2
+ 60D88E25973DFC3941DF4A561132F77BB099A82A2D4AD22094E536C8939AE4A8
+ C9E0E5992E5968656C69078F1D4B496D90838EF763A4F31748DB4FE0BAF1184E
+ 2DCE23F70D9B56C19B8B66F86AF41C6B3F6B092441F7A366F30F4D2AB81FE676
+ 951B8E2D119BB4EDDDA41CD1182DDEE37B0E9E4E5C0A71A5ECD14A36314D4F9E
+ D669052D65F326E1C590E28A7CA45098E1863A7E08C539391C69DF85828E2F70
+ B0B01DC7E0CADA18495E4F7073522986D09D4C8E674F378E2070099FE6C2CB30
+ 25B76D58CF089C087C6DAE42177F715D08034CC83889C0D7C0000694E38C33C7
+ F7A88E8481C85D672947C6CDD3A367D7F8CB4A54744153A01C1BD03018451721
+ 1207A6FEAD35D2074E215D9EF365CDC8D63DEE7B170BD35E5ECD3E1D51BD883B
+ 6FE707F15D6D3C35A13E0218832918A6EDCC3556343EE1C0E9C7B5AEE7A469AC
+ 5C5FF43231C6B3F0AD0FB607DDC5F6D79F28CA343E015B3D25C744D1A3025D2C
+ F92B7619D41B096528BC3DE3458520212B718937C4DCC0CAD0FC17ECBF6446F7
+ 0A968B971F1EEC2C0FFFEE47D96334AD735EFB10C6F5165E17C33403FAAE3479
+ 190172FDA6FA81319E76E22E9C8733D34E9E8E8BD06C6F7E91E0A6E0D192519B
+ AF1B2056DCFCF5621BC853FBDB9E466BEB4C81533D55502FC3D74CE0C3ADCE2A
+ 7CFD54C602759E7B358CCB8AF0A25BDE8EA2775F3652A8AA46A1EC1B7A055681
+ 645596C405AE9CD95952F94CDF8414581F9A035341CA3822B8F0F5C7B5AD810D
+ 7EE95A06E5747166899ACED3EB13477E7F65D25C95557B726C9E77FEAE4D9792
+ 8CB476304410FFD539B48AEBE043EE40C585803778F99EC3E07882694B9B1F9C
+ 2A746F55F107F051855E7B5D100C79647DD9AF64F190C63F793035274F1EF937
+ 1745A8B10FC074A9FC4E39A6330AA0A96DED2945F423EB437CC14FB5DF8FC1B6
+ 93137CCBBC32ADB31D0D7F9A397116EDF33CC9624BE22C04BC854CA4872A9879
+ C6AECBC9FE8518D3A798E6C3C2D73236F97D8871026C9DD24E3B122D3C0E09D8
+ 558BE7D379EB8E294BBF7E588825F1BDD3E77B2CA357FCEC8B16647C126145E0
+ 59DC2DF8415C68ADF553C635D6327330636BD0D9920657E7AB0BA4EEC69BAFA2
+ 1A96D8B86422B9627541219453187E80946C1AF31B95757D544B77E5372EE2E2
+ 0D63AE911BE1468AF3858B84287150B1013CE1145ABDD8733EFC4902D333DD6E
+ B96D9E78EC0235A1CF383B1F0D41C1EFAAE2351C3DB3616DE62B84542BF9C0B0
+ AD4A59CEF2E54754F46DD351AD70451A18A5DD59C3B4156DD1C26514165F6E18
+ 31B521324CD5F9A36ACDFDFE44A9CFBC8812DB404B3B04A2611CB14B141E908D
+ 64DFFAA0D7865E81F3F2A45D4763319893E2E087304F7DB2ABC13E4F5B8CBF1B
+ 5AB8AAF374BDA6543DFDE44BE4EC9830B8EB0FA960DA8D38733887C80EAB5F7D
+ 1E72C61CDB990E5309765E76F672D606D5AA6CBA685141773C4A9C340B5DE2F4
+ 5F00F8893E076ECE44191A04740A6D54D33D86EBC3753EC25364C59616FE666C
+ 6829EABEF91EDEDEEA2A62FBA2351FE69FD23402EE69498EC8C2EB06CD293D0C
+ BB58CB2391A122E962D78C966E417977856B4A5A12099640CD932DDD4F68FEF7
+ 2A39532585C34D7C50619D436372E5E7D4016667B3749FED0E06B5B4E67061FB
+ 2DB4B03C6D3F2D42AC1E0088F9732BFE26D57E5D11D90A0C41074FEF204DC6B6
+ 07C85C36EB335B86A96E1B5C40746B5F1496D738BFDDFBDDF3001C1934AD5AAC
+ 5F58637A993795BFD13D139D227DC2EE466F20B0B796AE6ACB279366C9AD771A
+ 59B056327753182CECFC5FD83257BF44FBAC3EA27DC533B387C2F54595B4FA43
+ A868ACC4B09EF6FFFB0DD79CB5BF2CAD23AABB9B8C104D5468517CC00CBF049D
+ DC815BBF32DAF5EEFCD14F3965226D078C6E761F4892ACFCCE7E187E4683E3B9
+ 4A89CF51B91089F5179777092F82015278AFE7E5772C5CA5779BDAC1B4238F6C
+ CF18797B8D6E817DACBE083EBA3D888D9B65E024AFAB66E2A2F0BED73279A1C8
+ 37ACFD1833C26835EF172F5E2E9C51DB1F50DBD1F57D303C616B72EAC690532F
+ 2BE287C446E2BA6AC8C6C040D90C07986264AB41007E77FAC48FDA9781A974CF
+ 5F829D7D147FA2CC89AE3EF8216A9673839BFDB33C5E74C1CAC7011D615CA214
+ 14F4DD38FEABC6C224407C62FFFCA58E49C6FC64C275618AC8A44D8AB46C054F
+ 48856FD08011060D4A582134E960AC487462C4939EE03CCCE9014C0D7BF12251
+ C996BAF098C748CE041CEB1F969527C9EEE6EDB1BDC6E838A2A2A10815C6C612
+ 8A4728828F488768347ECF8613FC1509BF3228AFC8F2F49E38E1549975B43C5D
+ 781DA3F09A013B267FBB9C60CD9BDF401F8B365C08B82CDFE63FCBABA05B7FE9
+ C399CB5FC5A63962098830451ABD107CD734358E48DF4AB5A162C45596BE54CA
+ 7A53F5F9EBFD2ECB1B220125585E70CA4A49327EC5FEB59157CCC775E1184B3C
+ 1ECBFF5331C7E9F32C8D2C9D41D06A22B36E1499989862CE5B9B035EB384628D
+ ACAD7456125467C0D9D47062ECC99FC78B3B02A1738FB27CC6904F33B750721C
+ D19EAD93A105B6E6B7BB8518A217916EF11346FA2D9DA68A011B8E123280B4A2
+ 1398CA59FAD1D21983D111A683663C1631B3C8A295BDD82B08D8E20E0E3EA480
+ 0116F2875E4A4DFDBB277C1CBCEBAE1660E744AB1BB8FE1F856DCC6488773EA2
+ E12B80A98A326C630098EBC2A3D9EE857E37CDFCDBA7F444D32B63031F825157
+ CC54DB1F3724DAA8C1EA78FD6D092481500BA5B179BB7B07E3584A026B706F6F
+ AA836C71014D9F3CFCFBBE208817162E520F5DE20F4D0B02AB2ABD1DB8531E93
+ E64D437ED2B860A0E72D3EB8DCDD8EF14F448B7F4E9442F999E323F07AF1A3E9
+ 529D2645DEC9174666D786E9504D8BD39B7CFCED7E84C98CE8FEE2B8724A83BF
+ 231DDF6A0BFD18C27E144F81C8470104C2CD826E3939BDADA12C5DCC9148FB6C
+ 93A83AD850F95CB3A27AEDB2A71D71155524530CC89E6535087A02F50FD42E8C
+ 20108F9B0694FE8435E9B8CC2718AF65A3CF2B75D3EAD06B961D90430FB0BAB7
+ 14AC7804378C2DFEB91715FA7B2DBE924DA968A811EC79192F2BFB4EA0DF8B29
+ 7229ED4A3939D68775B8E7C5DA7D1CFB6D39430190396D21E4D365836D35484A
+ 05B685C1792987AAD16C81ABBB9AA65882203756B824530579680773E14DA47C
+ F7A031613624B3C3E763B3F70F4D6AE20BB6CA8DE3E744F9A7E50AE74590515B
+ 90A48D7A890A299390F04A93CE1C3CC73D6F60EE9DD68560E94818AC18C5BFC3
+ AFDDD6F07A0A4349628241152D5A736E10A627399868E8F4334AF8EECAE90780
+ 05CC98AD74297E7F92E16A1F0930FDB8EFBEF7FD4ED8C95360A2C0754B1B05E8
+ B6568170F0071C17FC2A2CA20CABFB791369EC4FC19DAE22A4B166A65AD6AE57
+ EE6AE1604FD23E47569F89716ED68A673449074FD42712A95675034697421CA6
+ 8E8B33F113C45EE17AA634316120B5E32A8633FC9FBD217732F4C488745A21E5
+ BC93F56EB29693A6A7E3FA64FE3708A171BE18F779754FEE2F578E7018DDF7BA
+ 882D587E3AC376B7CA31F55EBDBE12B991A8AAA067EB6E38ED732E3A4EEBB5E5
+ FB59214FD4D0B8ED64F8AFF7668859C5F12E27BC30E64F83CFA1CA137D67B04F
+ E3DD001A91D3422C8F5A570E5E2589875D8F717D7783A617E6B157E4711AEF32
+ 161AF4FC423FD2EB71290716CE93AA53E76DC1CE2ABEA61FBB716DB769E76FCB
+ AC85CCEC0869168009FD1128A63C9D5E00E02A8FA05048B294DCD94AD9C5C465
+ 87DCB6E28C0785C0E9D82E737F44AAA85F993D9EC267F4955B1E81D90AFFA1B1
+ C9E5B3341B279C6BF4816CE369C82F215C9648F06D76AD2C6BE7E2D6119978F9
+ DABF6B6BB4D7B58217E2D279D4821921FEB8FD0371170E0FFBA9ECFF863D1A6A
+ 185638ECA4AF9251E0DC23E9EB0D73A59EFBD69F468A8DE88E309825AC8936EF
+ 4B2C219B03319866815A324EB1046389881B6EDA68096450748399B896E3C467
+ 28C646DCD471E5EEB35D015D5C0BADB49E0C1E840B28E9D75D9397D73F0DD92E
+ 998A4E77B806E2AB865A2B8016489D21191E62F07C1F9076408452F0B5BE2BF2
+ 9130685F31995FDBA37D5D79AEF0EF3DC2C81267DEB1A24E9E3568E4A5ED4E37
+ 75CFF5A1B1AA1C644784ADC41FF02700750E88AC25C54F821064A39434FE4702
+ FC37190825E7C9A235D11B5B06CC2EFF0206F457C1699FCB798CF79A44478190
+ 974990E2667BD521852C65B57015D6057E0591003C28842CE7CA667F1EF8F802
+ E1FE50CF7F3DF18BF7CF0CED44FFA60D7C18BD11AAF83161567DA45B4F0147A4
+ 67C26D9E5A99845E26388BD0317783EA55A7B031D0C4C6ABDE16388DF340441F
+ 7CB9A5EDD90363618DBB28357BBFD2AF7047A98C5ACE8558415A6626AC85769D
+ 3D54204D60D2D8CFC7DC01837F4D6842E4F514348E570588AC93D23BF53586F2
+ B18B63997F5DDB319577A2C653A97C2E417E01CDD6D85956E66AA8C47FA92EF0
+ E52AF1FB5E69D1447C9E6716A726F5C700C585C2ED3238CFC04EBC23E9025862
+ C899CB4F7B4162CA328D0060C6DBB48E4ACBB1708241A9A9E7B4A0A7C1535D69
+ BEA598FEEBA5450A157BD7E03210504B7EE9F6E135A1651976DDDAB79951C9F8
+ A0820A7BD684C4F19F486AB6AFCA05968F3D163F39E449A0804F91C83B985AFB
+ FAB77637815D7361C52A0CD21192566B78D1E54EA968E71A991130305C67D906
+ FB27661F78E53C362BB3F07C02B091BC172B58F153B8FED5777F9F0CE15B5DAC
+ 966AAAA2F1FCED6A4047CCDB680BEC836C6BCAF3402512C9F58CA45EED94E8D2
+ B237A001AB730320C66EEA3C978173F835E1124B712FFBCE9BF80E1C89D83C6E
+ 05703FA6C66208C62A1EFE7DB425E6DD3A92660A9D69A89EE90FEAADDAF7A575
+ DBE4DF06CE490B471A2A1D8F5D9AD158CF3DA9F116269B8C207713C44DF30E17
+ A17E9FA81E92A98E8E97FBD3A74EE05508A09CCF1E1B1A619635EC9709DAFC41
+ 7A9A640551AC8DFA014FFF047EA045A3A965ADB1AABBA76A2FEEABEA181571CE
+ 2FC8CE740865D9F9E796C2EA72E392422FA85DE5D61EE2B7DC1E7DE2C78085BB
+ DA4E7759C09ABAD37E3AEE7360407F62C6B5E2E31AB729BC47C44BC0C86D1F6B
+ B1FB01143C917637F279E0CE0A0A391FD231BF3049016C9E8AD063C6A03B33DF
+ 8F1F7A067F034CE1FD6551EE5E32947B7769CBC9142EB5020AC9FCBA8E9C286B
+ D6584109ED3F80D44D79704DFAAE4E1A58ABA270BE1833F50D08CD000D41F2DB
+ 8A4F8653720C47587620C9FDA0085E83E5C92BC6972D834AC7E13F092D327B00
+ 3907425ECF395A4FF64E3307D69C7BFFC62B0B7BA419FE66FCDC6FE3A1EF6CDF
+ E0D71C03F877D0D4AC69F52F4853304B22DD7778FA5ABA3E7CCE184EC4AF2D39
+ 6A9201AA0F0D5E31555EA390AB67BCB0E02E326FEEFECFB3D39F5E5D5B18451C
+ 422268D713C42DD8484FF98FD7616CC8337C0EAB8E9F5C424FBC382238095D0B
+ C676140E5927AA4451843D4CB99B8FF5275F019A92A1C0987D3ED9816B1AC918
+ 751C2ED6D66552BDCFBBFC47235ED5B937F6321BFBC7100A7CB909A45F09E817
+ 761FA99243CF85692B0E1D8BA741D3CF6FBFD48A4284A4FE226A2198A342BF2D
+ EC5220B69BDB4B050C1CF8FD58C1AD164A6F35946DEF77E9B0BFAD268FEFF5B8
+ 51B75790EA15A5FA71B38F96C5B338026F65F9704333637FEE0AC7C47D266623
+ 05BDA560FAD569B7409CEA12F1A9FBE422B06E17DB3768050E8E9EF4909CC725
+ C3239F4A5903CB56D47885E53C75991FB5B689C6E409338B210326DBB5E7CC84
+ 2CD091E985CC4FBBE2CC9C591DDA9F7DFCD3DDFCF9C27BCE2E8AF178F63FADAF
+ 9F699D64BA5CA916E68E2842F5B903EB3C3E4092857D117E2822AD2626F796DB
+ FA3C5BF1D3050A6C71E761CE402ED431F5A7C269B5E60587EA80F6629D41B9B5
+ 10BA4916F9CF36ECCC21A0A369B3629480D165033E5D86F3694BA63F0B187FE5
+ 2C63AC78F637A9D44D741E9DD65ADE7D183D6C95D20A4EE490C23A6D78F9E599
+ 67E212A6E505E03E0B341A7A99D24F382E147CBBEC2A78B4081A19E6198041D7
+ 676D5EF5DEF578C26D0FE8112883FFC39734EABCD3AF7BA6D100827B1F2E6111
+ D16CA49833618B180BEF66A5D97E57CE2CAD54EECBD8D118FAEFDC706D744F65
+ 5CEFB1206B7B290D630319381B59AF3FE4916E63557B98ED720C893AECD5F71C
+ 9F274BEE4936825CDEC55A9957EAA9279DFB8199F9DD09F497EE1D193253824A
+ F7572EDB3D914C7DD697E43633E7A3B9081D98A4A64C01249A6028AA37691964
+ 5897EF275DA4BE5112A4EF496EF667A15595E27C8FC61B3CBC567573C9EBAA10
+ 17B9CF8073B5982FECE65672ABB985C0B1D9EBED2BCA37B344A4BB5B6A3AE494
+ 01480092B3F30C8A5509DBC6DB58F6B427560581FBAF5803AAE0F7A4B74ADC07
+ 8B41E31B1F0F1CD93315A2C77F23B30C1B93606D6426E1C06084EB2066478DD9
+ 725BCC43941122951F5E41964C49F3952B2BD22A8B28223AF3BB4C0A569A8388
+ FDE3103556C958FB3131FE3B93BB1E0EA5C6E6B4E92C023989A0036C5B642B7D
+ 8BD827E9086F05D5F2D4821760C405F80E20046B2AF826AFA733EE66DC66398E
+ 4FD5E34748396A6725A86A40F38E906C7AC8D5C37EC9C4C6E6E7C755E8088B4E
+ 921EEC2A6B3B82DAB9803C5EA1DDE8C85850FB1B30933AAB04095400455A45F2
+ E2B3FDAD746FC66FF404A0BCA34256B90C1587FF9D3EB87A7983887B931E550B
+ 443EC203EF5A3551F54618E08B8CC47BF37B815FB20E13778A53FF57EF41E203
+ 4636A231D12D7CCCEC3111192C27E62F87AD9B3A33AFC726B8F1E8DE527CBE4B
+ F1F488DCD895CEC8D7548803CEEDE90A16C8B51ADA281755172044D40DD82E3F
+ F351C56BFC59B7B819FBAD34C50C350F04A17609AFAE08422AC6627F80C71502
+ ACBA87DC6E5F3098EFF82CE7FE64F40DD75C7E10A383D97BB5559E0B08900C54
+ 53F04BB45BE1C4F0238389079B501D54DC832D44213F599445229E184FB4EF74
+ 28A26D3C6797CD12CCD79593649A938B650522E405D366DEBD58A212F9253E58
+ 7C9BBC02B06B1CDD264B4F6F900CAD4D556953461FC08015D67940C14DEDB922
+ D04A847D4D3165875063D163760CED8D04A14DA959381FB3DAC024CD36FEACCA
+ 8CDA6C3C3BE761169DBA0A1C3599566B050C97625D37AAEAAC5658B58C768198
+ 673628D68A7F19FB83BFAF60493945574F3489D112EAE1ABC098B67E70E73783
+ 9BC0C87383A309802DF92FA3DD2BC8973F90B5D9DAF3C1A9F0F3D2CD37CBE447
+ 3EE5139910E956E80A9E9483FB419F761B046989F5149D3B6E03F09A47765E99
+ 4E77C0E4C8441601D9C1E9D4E368C537A3C999A6CA819F19979F341DCE36A3D3
+ E6738A9280C2E84466C7D84B626DDD71B68015BF56F517D920DB4612ADF55D3F
+ 6B2BD37E4AFAFEBBAD89B682428BACA4F91431F35284BF5EEA1C56965D348B19
+ 005B00E39E592A4F745F8AA28E4622346EEFB56729D68D6C7B9E52956A3A9926
+ BAA8CDB9F4D5907132EC8C37C3ACE2F9159A8FE709850F78D81272AFC34FCF13
+ DA60A5DF37299C47A6FDD5F28B873652D4B996EC3130EBB96DF1089D6D2280F1
+ BC85F0CEEB9C1CA6C47537696AB610B41FE059B4A780A6EAE25BA24C26053F57
+ 02DC4D604CD2B8CF6242F013ADD77310414D13BBD9391B62C96E58B0EF544EB1
+ 8A7DDDFB30E63C4C1AFA0BA074226AB52FFDFEE18E306AA20E826F43F96CA4E6
+ 311116C999A60B7EA4DEC6DF45CD8CAC6BFB3F8F79CCF788A2A16D7BB1F165F5
+ ABDBD305F8197943AAF1C145D457B52CCC8499BF0B88B6E00EB23F59343332AC
+ A610EB22E9A25F254E5CA730F8A2AC698648527E8558F9D9583A8A421CDD3AE6
+ BBAA6AA8CD28DD62A66E6E01AE145626515EE75814365F5CEE57840C85C0A6F8
+ CD9B79E0D60272DB9C3AB29EA55EB84F859F2C16FC26EEE2F50CF6F119576556
+ 2DCE29901B8029E1776AD7B6947907B2B8DB6FEBF82EE581BEC32F92CE1A70D9
+ 9E0C94CD0D425E2714EE3FA2AE4DABB57B02C4658BBDBE183C7D1E061D89D078
+ 7656887920843FCE8B3F1C7C6C024EC327F3AAC42CFB92EE9C8ECC6F1739BC49
+ 5725DC5E2B35430FDE38C65E2FDCBB80D70C6B9E31CF30FFE9A566A925C3CE0C
+ F7FCAF94DF4DDFBA171836F19523494809C619CA1E40E77344A2D1F4310561A9
+ A170F86343C3F075531A5DE073ADAE2FD72AFCB9B79AFBA5B61ABE2906E54ED1
+ AB6D0A6D64FF8DE521360DCF1E0FAD873E3B9BFCE5A1168D1B22715839A41E65
+ F7ED1B19BEDC13C4003BEEB789B366A7005DC230FF34D6E20066FE23565C3C13
+ CE93EB71D7149D088FEAF7DDFBA0C517B11371518E2B2D10CCC210B896B8DCB2
+ 4D0C4B27BD52DA60B7543D318C0A4A85130C23F1470D2792622303DC6DAE8FEE
+ 46E1FB5C0DFDE810C646D152058E610D9EB27DCDB14A19B95466DBAF21D1992B
+ 9FE3237823D5EE759129CCE4CE3C3C9E4DA19DCFC719509BECFD18A34EBEECE6
+ F079C2B51FE6E54E73CFD467AA687380662234D1F2760BE395B829E017EA845A
+ A09A4C138486A36A40D2A56E6E34E85B14C53E3204399EAF1F965E37ECCAEB63
+ 4DC940765902BE6838CA047AFC0966EF993F3B91D0C415F1CB3791C9A147DCCC
+ D3C989905135E43BAC4F3B4C99697EFCB08C2DEEA9C2B3E2E04963B8185DB8CA
+ 1D843E17D939A4C38E2A490169C1C150245F668B8B297C620136BF793FEC1AA5
+ 015F8570B33BA5F09FE99EF780B38CF90FD7A3F2B77721007D23EA78C69736B7
+ 4F85FD0B353FE684D496822FB8D361F09A19EFD3B02AB39463106E96F26D727D
+ B7FB50744DEF6B5FAB7B23DB7D4AF4EF16FA2D7A4FEE0792E6A63DD6D026E447
+ 0E8ABE5048CC9B149F6FDC58CB8476F9C71E3FB9AC39DDC1FCBA473DCB725E66
+ B961D4833DD3AC57B313DD65C7C58E9DF5C41DD4466D8696C75DF2A8655A0DD3
+ 8A8E0D7A1A75F5B1414DFB4CB834AC984E5D2AB3B0AA3ECF61F55EFB79F44759
+ 6C854322B6E1599784B32E024773263AD3AC07AABEAB9A25A41997F9E9417E44
+ 7C2E046EB194F46B43B0D976B55A392C0981AB99A0DEA04FA0BB1EAA3C7AB275
+ F96F5435CA09696E8D56020566CD98B657036C3417E25A2EF949F2D92CA1C591
+ 35043D33071449DBE720F1E37E84106C2B52C4AC8763C756EEBC446ADA164B10
+ 6C3F6B13EDF164FD5A641F2003671F5CB532B07C268B48387DB10E7A27FD85D7
+ 969E9C1C0F86AEA5FCF391A0CAF95447534DCBDD4B5502A049A9464946645119
+ 8177E0A3880587130A0C26453DB84B2FCB207953FA0850845A934F5AF8B086FD
+ 08D8A77B3806B15CD0A78D23079999D10FCD563841725D33D4AC98DB27B5117C
+ B1FF79282CCB5FE81892FFBA6250AE3019739388576C35D111B380CEE5C76CB9
+ E7B99897EA2A4540D90EF41CB43405D762B4DD8572F31886CE5E0B5F698F9A7A
+ D1C840657702C8EEAC46B9CB83E2734305BD3ED4E877C200F55CCCA1B616A8EA
+ 1C8A002D9A81A67BF828EA9313334657B53DDF0CD2753C3192099BDE5FF6C3FD
+ 5C40FF15EBCC6EC3CF6CFF3C2073F763015260F6EF080B8CB8A2BCDAF2CBF79C
+ 71873076954386AC60C0100B3BC880AA9B7B38417E2D57B6A8D039E31221C0C7
+ 9A69D44089E73AAD83B614590C962D64B4ED11863CF2AC5ED0F1F599E7B072FB
+ D8EE5A0E2CA76BDA290D7C91B1F8A811DA8B7024DFE5864B5AD59B0E49DBF699
+ 10329AF670D8655700C289091AA499BF71FF3161535A895C66A200973910C9DF
+ 7BF4EC97A84C50ABFAA5ABB8AF1F543E4D9CB93BF0A54D49D3D3AF02122BB3DD
+ FB391C8DA46E405803C6CBC6351753D9C2D0BA37BD6EEA7D19C163814A954997
+ 66569A0B61E8CBA6FA05116B585D4D8D87B5C4A6BF41140D591DCE282DFE8C9E
+ AF5DB34BD2931B8D111E1FA9418BF320B6A840B27CA9434B68499E78C182EBE9
+ EA7825484B59619D8520164D6418B1E79A1584F4C39509E07C288F17DD55FFF1
+ E13845919C3034BE7D8814B19482AEC0DF51EA069180E2197E72C53097CC8EAA
+ 83850E437A6AD4BF8106857A5CCEC87519613F9879121234412725332AB3D4CD
+ 1E7AEB224C62A392419691DB4F7A10284FBB2E8588CC7523127FF2CE367CF740
+ 3C3A095EDC71074D0568A7B8610594FFBB5726FA9EDD0A89BED44D5C5B88BC32
+ 4174499FB891B3111070F616A330359A70CC6ACF5897A6B9B965E7CEBEA4F63A
+ 4E9FE6A59DB12875C348291B10A969F8A2F9B6F48DEBDD08A15CCB736E5CFD97
+ 14F9FF6A3A01C7064732A7CC012C68468E365C8BED96294651D4832ACC102478
+ ECEBA3FDD4B82924A6E6FB047F31857DDC87AB523A1BB3365E07C6B5290B9F13
+ D77CA2D0F07C1DAF732EEEE77B668F452CE4062E179289FD50FCBE07A330DF79
+ 81D592198AFEE8C8B5897F4DE0CB81ACF1BA15449262E4C328A900C887F96B45
+ 409A5F4BFEA1F181E84B453848CE524E4C93225DDEB378963AF008DB52AA93FC
+ 7A5F2944558E0F5541121973DF61ADCE6128568E3066A27E916F5CC7D53C0F30
+ 92C1581ED74A4F85900B32D576789DDA3BA9F18B77112575E022A8C550772FC0
+ F4618BA71464ECE9CDD61CF80F3FA21A7475FED2C0388DA392E1902FBEE64711
+ 1F941CE93DB7673A00B2E2E8C4C919ADB51E017D342F36E222D9D448B20D8B2A
+ 77D7E30F9C8A141BA7979F08B55CD96CB71098E9E29BF7E3BE25CD5557DBF527
+ B31121074DAED3B553ED2C981146321E2F7B799792203D079EAB393AB76BEB39
+ F637BAFEA4B112B3B8BA85E7E5FF4FDCF1324244BF9F4DFC45E574CFF492D0D2
+ 021C91B3ED43D19087B982AE1C0658DB750B82664753FACB5FA2BD7BA6E0A818
+ 086FFBF0642E9A17DDB3332AA006C7DF11328CEEA0957424E4A68DBDD53B30A4
+ 9176930EEAFCA99F8EB42902DB226B9F9D1FDB1C0DA9F288FD7A9389F098DA23
+ C6953B57FEC7EC7B2C696D7ADA8463B3BBD88B08B30299FCACDAEBC8B5B4E6D1
+ 7CCC204D3CEE41CAA464D28C556DE63D765AEBC3012CF95FCD51DEDCCF78DCF4
+ F7E776203353AF7D29C92138BEC600D2528EA73E89948E826104780541EAFC52
+ 1E031158A7E3E97C63509262B358897FF919ED4D9931F1D2848D19166D9F6932
+ 5B4BDD00259E68C93AB2BE828904685DA53626C4E967CA5EE2434F0E7190BF28
+ 077D1F563468B50217F996A4DC7E63C41EB0B1825094ABD99FFCCDF3C3C21CBC
+ D0BC8F470F89AAFDF5AF82638943F7B767D7931BBD691384DB9DDFACA758CE6D
+ 8161C82B1FC862B2EFEEA70F636C3B071E364C72BD3987007746DE460487FD57
+ ABB5C8C9B273D9263CEFF5232EE91F7BB19F51069917A20238EF31A5EC4DCEC4
+ 7D9204411506D9DE9EAACA0DE973E1287F040D136CE8B24F571967FAA6A793F8
+ B30755E66E87023CE7B12069CF98AB1A0E48095C1F3678F862264BCEF6BE736B
+ D91C10912D09E570117AA75782724FF97D9F7976381FE5E5553BF06DBFF32CAD
+ CD8CC8FD8733A98C8F32C0172A704DBC70E7369DD39AF538327D8A8A54A7165B
+ D96CD2EC86BD04E1BFD3A1E79D0D55545EDD2315B80C3A3D406473B3354449F5
+ 41555B53250C7CC13A7B749B34CF86601D2A46FD1C83BE4C88C3DD86E6DDD855
+ A6A0F92E1B9BB4D6D4EEB2ABEEFC15516235006B229845B83949E56205879823
+ BE67506D1D8C4661D20AB7587CB3B2B4ACC8591B468B1F0EE89F00D2B7DF9D19
+ 0187E8FA7F677B699C69604DFA98FCCE951892476DC3B9E07CC565C7034CF20E
+ 0246F5DB19123C0FF6191AA1DF708A93638787CEEBF0A841D496A8C1305161A9
+ 32D3A0D0F90418347FF766B6349D86DA353B4A36F1B3432E8674443E9AE57AD7
+ 06A514CE91861BB92836DBAF34B8E6652D4F652C3820AED48C1E467C7FD768D5
+ FECDDB90505C2E47976524AB8948F1C4160E7AC31C2590A0B70EF4F6F28CE9F9
+ C7A30013BFD4CA7FF90263357AFD9C79EA5C707D59DC58DDADC75B12224F6CE1
+ 1AB21E7068BAE899B64139B60EF9A09774D93A49C26DC14149C77A5A71B09F48
+ 4AB3CC39DF34BF26BEAF165A7159E6B855C04C04349D058968E2E83F7FE9D130
+ D52F11118371A7BDD623E4B68F2CDA841C050094E194B4555694C2FD7240A331
+ 80C3AFAF14CA82B4533C87CD7B124406CE20EAA64D351AA60ED0326E1474C449
+ D4A6968C271CE710C558016E73B81C6B5E164D06A53FB65AEF72B5C3773BD3E7
+ 8C74BB6034E9ADB3A55E13BFEE64A62AB699FF148FDBF1E68372CC19F53E43EE
+ 57A1B39515EEA5703F64CE09399C007851D02F526963926794C7292C20DB071F
+ 0E9FBE66D344E83AFB4AE23DFAA20815D652BCE9467B03AD6A6993A7698EE3C8
+ 1BBD098CF4AF33BCD313E65671D33C76E7C42032BDDF49197D74A4F9A1DD8FC4
+ EB8A7B82ADFC9C584EDD2EE75BE3E0FEAD9546DE1B93154A94662FFF639BA76F
+ 6BC97C9B998108E79DF34832C7EBAB83DA810AD5F31FE266EFDD502F0565B6EC
+ 57ABB61A6F938730949FE95FFA1F6876CCD53D804D695D17B85F6A13472D789A
+ A709BF5A1460985E0DA8FFF55981791B45E4CF02B5606DE6E3BA88BB3539B63E
+ C3FA2788AD451A21B6B82F4AFA65F82C208358BF41C5D91EDB344BBA84F989FB
+ 87730B891CFD40760DA1FD3B9B8532DC046D43D5BE6489468D6652E1A394040E
+ F4F97F6B277CC0DBDFC77F2DC31D684BB491EB6CE6FD3BF0265E949CDEF59FFC
+ 71AD19D6E4579FBFAAE0C6D2867359D755D3AB8A76F41C11205868CECC4281A0
+ 3FCF14F1A546CA5064FF141CBD6D20AF4228F84655E13F10892599AD809E32B6
+ 2FDC20E345D17F22B514B89E645AA214EBD4F37F266DAC948E7505E30A49A869
+ DF11CEDD329960F733CB0C5E1D37730823DEA0B814EB36C09C827DE906EB11B1
+ A3176C60BA920C0B1E429778E32FA326CC392A2F512188D5D7A302C41F14775D
+ AC93334CC84327DB686C554D07F68FD79C3D7C87A94485C1C9048463FD2E255D
+ F7BA429687AA6432A60B4B2851675E8A6D7660692FC0BECA6E7C565A19D25080
+ 69C4F4E337C20521CCC4FD6A9A18E4720D39A78D3692867E846C43EA6E34DB77
+ 9410AB760F51FB5154C858549651B41B1AF41C8A5C5B8EF349DA0AF403CFBD98
+ 9414C39AF5FCCBCC24BA18726BC906F389999F0B9A677294D24FB49885E43E04
+ 2DE3EDC41708D3EB3DC88F59FCFC03F0723B495FFEEAA932AE3BAD0F9374917D
+ 5848C3C990E8B77866669068ADC7B7C20FB1F44FE3F73D3234B470773079DCBE
+ F29ECF3518BF1E95A785FF6A14A6C9E6EE6ECC1BCBE07C7003BF98BF43FA2728
+ A17CB104D420B2D2EE35D6A7492C9903E46535A4673D49DC59D304869A34E922
+ A5384CB646CA71DA659BD9AC068B08FDD65EC2DEA4791757BB73845C8E93C45D
+ 2741CF3300AC21468A9C4E8078C5D5E9171BFB9ACD734F6422AD8D2461C5C159
+ 56BF1CB2C68422031DCE68234E1BBE63FBC6E78179A3468338D3ED2CE831AD48
+ C5FD35888D30ADC025BC5D740D4CD580B3D3A92570F68CE5AC8E9E20D7F9C4DC
+ 4D185877D61D217BD058B835FE25F3C8CC6BC0DD619F9857EC2F9131C6DEB9B2
+ 893301002AC443599C2BCE35A25C50F3C446F1E703F3693BC1D5EF2D6D6D3178
+ A1448F55924CCABC05D458E47ADAD89D14554F92085AC355B26440E7F8CA2263
+ DDA3369902281BC3C19607C519A09C5FB1EFF478E1870DC278FF4498AA1E8BB7
+ 12A23693AB8639CB5B7893BBDCB84D9B88384A27CBAC524DC9115B7848322662
+ 3D22F3AFC7D1A1CBD5D6C73B1CB6273C816FC68990B2A7ECF4EF910974123F9B
+ E09211A76A8A5DF469BA835EADB3B06BEC6AC901755A96925121820D2FC6B4E4
+ 668F0EF5110788FD5B504ABF7B5DE2B9CD641484D46A024B0B8D0E57D007C385
+ 71D3C280A832D5B271F5C53DDC36A6C33EA5F4B1D4169C92FCC4A238D7B09217
+ 25E2795FE5B2C3E0E0AAF71804FADB2C95831B5B199BE5B466B736878C72409F
+ 7F386E0E6E433C2D2D167CB3F9B2393B25BD10870AC42D275E63100B00FA5854
+ 74632128B7EE00D10B854BAAF8A0EBC30B2F9806A76810CDF039DD5D35B1C069
+ BD5AE7A86A361F44648D549DCD88F3E10DAE649AD0BB5B3565187C6D106C7A07
+ 89D47157CF9E5A45DE3002CE17E8A1A7FAE6C51A541911846AABDE9B56C51777
+ 8EEAC2F3104E46CE8318BF47AD428F1A43C5D890356467F26D8863CF5A4030D7
+ 40B2C36A8C5825BF8612C6A560557875309E684C0CF2190ACD40AAFBB6F98910
+ 1D35131FE791F03394CAEC3045E8AF3FCEFA529C6042D008CE3B5FA02F58F42D
+ 9DFC9B912A435C683280D4815150CFD2609099E07E1087733863E4E89F6A3134
+ 6731402B885344BA762DABDF545EDAC16BDF01AD5340345C6F60194425C09781
+ AAA21E4F62A50DF83AFE3AC0F93D7A13048E15488E9AB7A8EA41A51BD212BF4E
+ 75D99A00AA2F4293AFD36CADD0B73F71DAB95376275F0FC27B935359B5C01A1F
+ 5270AA88D1C982D764C88D93D3847E22918C40E0215DB96D520F6D79EC5A6C12
+ 70180E065E34D100E62C82FE9D650380E0B3220384842F03E19B3F8860AD96DF
+ 4D7D84B298564390FA05A4FD3F2A49962590766A3DA30008A8A46664A807D1D6
+ 60E040F76A45429EEC34D3CD0BD30C3D1AFF8A1E6D6C826E4B50F0E3CB34990B
+ EC95E8D4ADB241C17468ED53C04FFF1D02A919C5E3349729AD289CED42646EFE
+ 727582FE6FCB4059E9A3438AAD8056B2408E4BC75FE890476991752F0AEF9352
+ 681BEBFAA925104FB814EFF51AB074F80EBF507373D0FCB1185CA04B7ECCAE28
+ FBB5B1A90B5EC87876DB4278F463382245062231708DCE571BAF681A346A2B28
+ 479B63E2831401B11065C94B873884F85ED4217EEB434553EF8500145F4C777D
+ 9F56056D1C8FF590AFDFA2C439B23AAB649F61758013A5390C8189BB2E3F4D1F
+ 0AEF1F755A1F622F5902CA9DC89C42AF41B0503EE56E42162727867180F5BB01
+ 5435253F38D1D0AD3EF2A84F4F16238FAE52CB11FB5A2A2D78503F42212FB88C
+ 4B41F68D3C3D07FF0C3557B96CB897BFD307043C45C13D772A35B4C4543170EB
+ 74E88217BC7415201078D6D7A69D518E06BA8AEE275030337AFECFFAF4AFD885
+ 3A0B0B7A809810ED609698F2A50C66296770E607A739C467F8E236EB24A39369
+ 6CF17A84343CAEED14F8088A751EAE1047D6807E6268ADADF04EC2FA41935988
+ 302A8D1759C3591D50A43156BA792155DFDADEB64D834AECAD744CA40530FF35
+ 9FD272756A676F9BCF417ED1D3DE0EA5DF9187A5469E69E880966B9F32CFBF59
+ A063C93AE0720C67668B17231D74AC5D5842CF86CB1745F224DA0F7D9F55AB5F
+ A3E4378517402171F1414E085F97716ADA83E0FD0CDBF502DE286D2F4DF3B670
+ 4AE6B942DFB4EE55A7FA90F6266BCB4E412FB6B3D973C6DE0D2BBB7E0CB0E782
+ AA51D84EC5475C9A0B6390A9ECEBFD96F1B3DA6226562DFF10FE8641F4916AE5
+ 7E2EAC73621C03B3F739E5CF8EEC79753D9B677C206E0DA098FCF8C5BD0D01DF
+ 978D067E5CC15E9E63C97528CF518848B1F0AF43786CCD3538C20129B9AB6937
+ 56CDB5D21E472EF6641FFBEA9F5D6653921F32AF69572E9FCAF4558448B57068
+ A885AE395CF08E78145AB9AA0FB1CA1F186F0AB715B59D5B0791225A53FFAF1C
+ 3C5FE085A09918517C967F63CA8AA591DE2AC242539738E10041FB579249EF1D
+ 69A623B2D8EEB51FE828F03680AD890D50DBB2334BE140865865B63AC4F1417E
+ 4825C690D5C50F10696B3A314E704C56963D3F78A1A2BE72E1DFCA466843D6C2
+ 1D4D064D4912987785522659F71E7369522CDF0F2015211B3E5B2F1B17FD7278
+ 7FD69B82063929A65012A208D94A0874B9CFF274D2EB8D43F0FE1C9983E49F79
+ 0BBFE53EECF64395D7667BD2A5564AA1571B33F91EB72ADA4FA876D2E671DC77
+ 5EF232EBC0213CB168E6417596715D13413F641D7896AC29156AF6632128275E
+ FD63C8983E4B80FD3463CDA5E79B3718365972A057C88BA335D13BE19A45D584
+ AA8FDBA2148D8F3B2C249E702852A43502BBBB10938CEFD550DFB8D0F9763177
+ 650457C2265092AC3ABAFDFC93D9FA46847743C81A7976A1FE6B17D1E4D497BB
+ 141619A187C6A56E2BA86899395B7B6001BB495451DB92FD0239D925C44B84FE
+ 666E2203032C51D4839E271E3E500FF3ECAB8DB9E245A691E852110322A1E026
+ FEF39BC8DDE46A803662F41F38A14C6B7B75D21E18CFBFDF621C1DF63E4D58BF
+ C542E54F28B5AF2DFC7CC00294CD24D5F12EA06F1259A882ECF2C32E1B679516
+ 9D4CA1D5303971FCC0951FE0F1651CF28FC9F92CCB3703B524034482DB2934DE
+ D92F5C66C48F9A0EEA490AA4E5328B7067D661D4C0F3284593D62AF061244C97
+ 8C641E6BCB93BEEF4F1A93F6FCD757BE1CA5D2EF11D21CE56D2910FB3CDDC8DE
+ 89BAB3BB18F7634A1A802327090A538A4282F91AC46D6F4C15260F76FAC45598
+ 65E5AA5D5E0538EC7E091B104B563405AF3224AD2E60698B42923631EB748FD9
+ 24A26FD965A55BC6D0C490D3A901C87AF81E133EB92B134F38C24AD299020281
+ C32BB1FDED001101D25DA65A076E0AA4F33CFCCD46A34F131302ACD2723DB769
+ 646A62BC17EF1413E588FDC8BCF7DF3ACCA888BCC1A34980F4810293CB7D0354
+ CBE4599094DD28CE57D805DF8BCB7BBE8687A3EB39EEC505BA1478D377AFE22F
+ 2B973CBE790F858F0FDCE745871E92246A7680B594DDE5FBB7B9259029AC29AB
+ F4239D50FED5237922903701DE63675867638AD233B1DFE47AC2D6D709F04ED4
+ 97BC682FDD864F41F56BF8001406A9F62FE06A15DD6AB807D7FE52733E00A792
+ 39DFAE7E684FE46E5AAD2D7E178AEA651453F7C585A065DD8052E0D5EE84E651
+ 75A09A313CA3F521C57DEF18861B5DF88EF9DCFBD0B84F5389BC3572A4065541
+ 00608C9E3473057C8998C9D890C3CA79F756B161BAE9F75D3727B703E4AC39BC
+ 127D4E381C86CA92DD831FCC76A3B78B6A460D13042B171391FA0E5564CCADDA
+ A4CA6EA9CC5D6FA432A7CDD0559B6CEAF24740CC84577EFD6AA0A56452ABE5F4
+ 73E01DADEEAADD4A5A346E3CF2E5066B24328699448519231DAFCCEFCBDB5495
+ 3FA5A11060E1709A4496FAD1E89D97146CF3F6A0C05C577A2E265338FD9FD0C0
+ 3883B7F8613889FE6D5262AB02EF81478CB315E42B77BC2650330597A69EA935
+ 236E40981B6C7D8AEFC24B9E51900F6550B196514D69C4B74BA842EE8C332614
+ 8D4EF8C9244C593FFA6FB4C196D1B3F805032D0831E6BC493C86D2A66D672476
+ B4F8434CD2CD023558BC2A540CF132FEF29025D7A1B7699DFA4AB63A614A79DA
+ EA2FC825A35B61E0A42B51DFF5E0BD751FEDEEA5BB1CBD0913639C69CDA2C8FC
+ 5A5BD142C5664D751CA83542C72E876EED4AD8678537968FDADE56999BCDE583
+ D80A680A57A151F174B317DE5C5936955BBD1387628F95E98A2CAA217272A955
+ 518D79267B0315B803B3814F874964F42C7452E24924736AD68CE3845B0752F3
+ E9F0832AC3A6932B2BA246AFC091201D7A19DD76075F5CE36384B3712EB1D7C8
+ B8DC9C867E2A68BC3B773BBE030B4E466C9BA967E45B92D53496FAAD421ECD22
+ DEBC309695C61D66CC98BD5330D8A95DC3C60CE861A2B444DE7432FD763B9D8C
+ CB53D83F40851A8D4583FBAA1AC314CC9F08B3D891B0E63EC06737061BF05F5D
+ 5AB58585F4015B747AED2CF2FB55D5056DDDAF27381F29892E328909731234B6
+ 1BC6876162051D1FD0F3AFF77DDB3C8DB589FAC5A9B43A1CDF58028F01F19CA3
+ 41E3F8ED7107051663809E466C892BFD51DBBE02D18759E6793864FC068E199E
+ C1B91DD92AEB4ABCE0A0CDA11E9B2600B6373833E8B97EBD998618935E4804BE
+ FEB1025431F2A761B541004CA25E9A1172A5F0EE3E765246F593149B320C3E0A
+ FE96F2861929D927C14CA7A6E8DF7BE57D17BEE8D90D5AA639FD57B694457698
+ 9505E1C280B5E2CEA443E93B6B69F41FC2D560B6B3DEC0890B3D2FC5A2D32BA0
+ 3C4E1C7ED4353763B97C6F04C070643FE9C91755E5237D26E0D4EA46EF9F2CC1
+ D0D43A97A837B9462749B3F6AC297A0D387B5BD5C124DB3E4DF57B9531CC6946
+ AAF10F35B9036BC2C1E4E3ADF8783D2060DB207A8353E5002400976A36448F59
+ 792780C6EB65F6C642A22C0512FF273DC6FBAF743CCD8E924C14451E5DB60CFA
+ 5D2B125989D29229BCCBC25B89D497BCB611257EA358D40697E66CC36AC194AF
+ 60B26C16599986E0788246941D3E3006701F6B7AADC272203378201A855CDACA
+ EE86576FE1B0DA01C34573FA06A62359934354900C79A53BC43AA8EF8F075A54
+ 91B0D6653F617B2390585B88F71447B9B87A40A0E9A90BEFAB9A676EAC6F1FF0
+ 89B771804D714902E1203BCA0FDEE7857C05F502C4441DBB0CA9EA4ED6E9FF7C
+ FD407C178625EF9BB68338276B0BA383BB970F808B6EFFB1D8D68828105803EE
+ AF215EF8657C6567B89F9977E0B1B6B5A311D246780729E0DB16609C032C02D4
+ 28F6C4116D714C0D047F816A3B1DB5BA3015E0C9EB38CD32AC7A6AB53E7CA1CA
+ D8D91686EF1C7E53EFABC4FA118409FAFE0E6CB3AEAB24074C2CF31A2E9D6C97
+ 9DD0CA7E3D7DF5A59CF464E19F02ECC457C7521FC5936AFAA9BA7D01890E8CCB
+ 81889AC0F02C90697F3362AFBE5791369E1B374112E0815899C3B9F1B06F326A
+ 218EBE325333F8D564AA88072E281D0C675733841AEEB7EB7A2B02D07FF7C233
+ DABA1A225288801E4CADBD9998B999C1983440CE8008B613B94FB4789262B14E
+ C15920BA2EF907EC970111953BB3756CBB72899CF56AF67638BB932446DA228D
+ 43E136F5D2B8B2145508B65C1F78D190B168546669C30AB1A1F6B8F06305A7F2
+ 0DE39D2B147A1B5918701B4850EC6C9CD9BEB86C5AC8F359A4B866AFF5BDC717
+ A3776EDEEB7FE5437425EFCF60C968F9EB65BE41D6CB5FA8768178D3EC94ED61
+ FA5AD66ECA01027044E292EBEC384D6FB64C67F6BF7A164E82F5A75BBDAEDD54
+ 11616AAF027B7DD6D9639317F2D59AE8E3C0E2005BDE0A79DF12A0283386611E
+ EDEDF8F31944A567303381FD5A34F1D5F49B793681E56BD833CFC98A08EAC312
+ 0A6306ACFFE87BAFBABCFEA46899F4AFFE10D226675A4BF7D93AED7BD63876BC
+ 69AF8381595756FDA9D15E9B625A1FFB56164CDE2C97FFA47B1462897E2420DB
+ 1262B172CBB317C2A870F453005DB58F5CFCBC2B4FA325B09ED2B066BA4A1731
+ 86C07654AFC48DA0B86AEDBD41A8CE357F52FF145C4D55D6CABE67AA7788B6F0
+ ABDBAC3F2936083B690AD8D921131D0F72C223554B38E3E20824C48F6D3EEBD6
+ 49D20EA3D8EEDB03C45EA06325D2EB245670DE26E5F1C6B4B2D8AA8578793AA6
+ 0C6EA4ADBF719A34D5EB8237EAB92A22223FD62EC37654170D2EBB5AE2DF50DA
+ A0570D531D0FA6ABAEF20F0D553F2E8975289056918E2937D29D356200C9C273
+ 554E1DBA61515D0A04B7C9C80972F42B920B0001139D91741BFE1B561874C9EC
+ 97D70350F1F2AD346C9ACFC87B1D12AC731001EC0BA76DCE4444185E6D62CE90
+ 4454EB5826E1D1C4B97BE2475986E75837FD8ACD3BD25DD790B5937E2D5709EC
+ CD31475401DBE9A8C9E3C90C2BDAE36C3D383587CA431A9020335E5C20929256
+ E4139ECB0EF66730662407B3D1928E9C0C0EEB1F3359107144654763483C20B3
+ 772DD0EDC941D5F58331EBC564B172E1DD780FA15B1069DE2FD40AE89DC50E47
+ 0CC9A551A1A25B53BD14E3060B3AADD17E7EC51CDEE593CFCC452B4212F96ED7
+ 4235C239C08BCDB41A17D82B6818B42674639FC16EC411B0EE35551C0D440A75
+ 0AB29CE4EBC3087E8B388EE9CEEB267D9CA6F712904C2BA7CAD06E7CA382825D
+ 775A9935E7B7263E628A71F8700F0CFB7DDBEF16E6D79A056F86FDBAEDA52C4D
+ D253D3C7C8AC2FBF80162B1AA540E1B98103D8DAF91F4A66036EADCF9378D0DE
+ FD0736D2BA1B927835D016174E50750CBB6E09DBA8C59396DD076084957815AC
+ E19EC49F2534A71A77E092C0F4334280783BAB08F93AEDA960A1FC8C038D6458
+ FFA03ED66CB775802F4FB356DB160445C013892E0849035778B22499BA4C2001
+ 89F6AACAB787FA071CF6ABA27821900CA88A70B344C8FE6BC4106024F40835D8
+ 0BAAF348F362346DABFE3C840B93BBBE04B2257AAB2398A41EA399C10CCD45A3
+ 8689CAACB383754E93AEB8CD8A59449887D7A65C609CA3FEC70BA9B97BC11C19
+ 3AEC5AA8775E8BA634FFF6DA7F5A468E7CCBB19AFBF9538115D138087544DD05
+ E83FD04DC50C61E954CA44464BC8ADB19B8D092BA80F8065B9081F276CF0B2D1
+ 5771C1F99B355FB04401516546EE9071725B1EF7149952A47053AD40E36C023C
+ 4C8E8EA6CD80FF2BB23C30C60DC71BACC014A3DD24EF86B0B158915C95273C94
+ 6F933F236A60AFA21A486577ACAFB0665D1CF4049EFF2189EB3496340FC71AB4
+ 7C5B8ED45271F2AD2302DA402F8261AEF571A86066EAEA24567F93A67109294E
+ 973E8AF1E33167DDEBD79A6C43B1381509FAB5169FFE9B9BE8194635CB5980AF
+ 9754B1EA56180B9B67EC7742955A4A1EA6637D46B0EB43B5CA7A54911D79E2FA
+ DF9AC7DD6D0E8EB66A9ED2BDC199D95BE581AA36555DA2A5C2F0518529BCA4D5
+ 5BFC3E6316044FF55897F1EAAB59E2BA492B90A2ADA7B62EE88B6964FF6E1557
+ BF8D0BA0A3A464597646B32B4F0C51672515D309C8FA9EC6E3B0ADEF2E7A6046
+ 6DBCE69AE7FC23F802F6DB200C5015D308136465804C28B38EAE4DFD0EF5C745
+ A6831E2AB04C2763E49436E23DC980F8CFB8B403D26FEBD249F551CD76D13645
+ 2A59C25A4B25E4CDE421828BB8C96A77EEF56A70DE3E7B6BAA4F00905D345188
+ 5D0ABC7FBC4F27C67DEF29BC237AED6CFD8DF08FD3A5F45447224B9B25B16852
+ A8114336FA3CF0DF66A3B8ABAA6B75517C582D5608F50898DB9D41832E49DD50
+ 4950337B07CEA14C06C3034F16E3EA8360399C74BE40E172E8C1CB25E14496BC
+ 3CA607FC5F7EE3C77EBCF2FA424998A53FE73D8FFB90259DF706142E05B8F185
+ E4F4A783AA1B6BCB04C9EDE7977438BD78F1BF63947999CDDB8268D4FDFE96F0
+ 4D9687CC919B5C7A7C9E964D12A9EC42099EA839A0313962FFBF796AB168538F
+ F27A622122B228931452EB8AA4AEB99D1F5665EB67284CB39DA572C031246740
+ 65F2557F3B3A407634FB16FC54832BEBA6A9456DD43940A3CAE8C627B25F386C
+ 1C438666852A5108D7A03195FF09DADE61B5E415C20892293A68FEA5AA510F7D
+ 8846D78283E2CA86E44F4A496DD5BBD3EDEB78559E4E6DCA096F5AB7DD8EB460
+ CE79E3639312B96F1B2A85054001584A95A74953247495D72312A77077CD2C53
+ 69692849FD94EC512FAB127AB5D0404CDFC7D1BA581C27812A1841C659D73170
+ EC523C29E80D82FEBE2F6C8C3C4312B7C0DA073F2CD472B626220509052ED14C
+ 9FFBBD0A5E500DB024A0D7CC6188FA23F555AC8BEC1BD4D2BEA69157E9220BA1
+ 47803CF44B7965C340C31DBCBA4DFA506B7ED096E5E6AC1C82ED8B75D7BE9AE2
+ F04521ECA7D6F127160097CFA06766500DD4AD7FEC0E2A6915D525CFCE439425
+ 1E8C104FFDE5CAE394F80D8934AACB6925AB76F0849F1D578358F78810DE1B02
+ 9A62E208A2727D5D56A4004C267B6753E9BB1A5DEA2B4DA0F097957E740169E8
+ A95E65D63329B0CDCDF8A7DB27A0C4CF9BC6416C370999B2405994172A9AD1A7
+ FAD4428792E29E9269A118DE8F88DAF266268DE08A4ACD053F2F7DA89BAB737E
+ 866DF66608152DE7AE798594E218126F3D53A5A4CDA941F8F58652E69143512B
+ 46E46B110F7D679E3A385BB51C53AD8C23478CA045F03850DE3130A8C6A67237
+ 005A17D16398AECD3CACF0FD3DAD569C8F4C4BBEAA62DD4C0134BFF1C6F1C79B
+ C68C49F2DC2429C3F3CCFD86A80F778B179B5358943BE6C83D04000A3B32E092
+ A5E732E7054149B241C71542ECDE40B8253CF61A0EC91191181C11CB1CD7218D
+ 2D3A25B01A3EB0285B88B980E8723202F994E2A9EDBAF55F39B822A6719B8DAB
+ 7A86F4DCC5AC19FEEE69D5D4D9E3AB5E0D6484F59621577655323A8268B6A664
+ 3E1D03EF87350F96A8B20FA89112BB88D32CB894A6073493B705285BBDCA5A59
+ DB09DA6377C4D66BFBCBA1D5714E004832537F1AF8BB654FA59EDE990D3EDAFF
+ C37078226C0DABD7306E8CF89F415DD2DB715FD90987E3B9B9181B78E644F691
+ 256330E53895E8F0D53C8D332413D45CA270CEE2366575664DB44DF2719CC4A5
+ 38F999638924CE5A17CFE73AD2A20FBB8126CBD644663EDA6970EEA2B09BB669
+ 1049A57B3364C236BC3AD2F75A79718A85B297B9D64E2AD16DEA81DA44B97F1C
+ FFF05376DABA294BE3FF560AE2E147B61BF68ED3EACF3D4D9E64446BE6895BA5
+ F7D57C0CE9657C655E8D27A07C1A6C06FAC33A4C62240A1DFA7A581D72F470C8
+ 8F6A95A9F53C1363F0060FC8630FACF4631C8794524626B7BF791990783E38ED
+ 7C91AF835B6206669C2D53B43AB850EC8CA67ECC722B7DC998567B15293A5671
+ FAD97D2397BB1E6DF8BDE386A93C885DA6FE4277A4C15B6B5CF3DD5CA9C5F75E
+ B55A75469A2FF8F6EB91778758281621651EE7658DC3EEC042FDE2B1EF83AC8D
+ 49A7F0319639E85911A6249E4C6C60330BCD27160D4F884ECE3D7D2EB62F8B17
+ C53616B5C56E1B3A955B057D4C9F0CB982ABF6B3C71FB960F84A3D2E43A9AC79
+ 74DF73E2A960964955F56311C7B1E9910A8518258CA59AAAD6B36425471EBBA9
+ 59A01533D1B71A5D65749CF73BA2DF5826755DEF046594A9D830DDD8FE2ADDF1
+ 10DAC4F0C4224E1D65E496016A615C52D743BD23CE241AF08236A4C9EAB879AB
+ FFCD8700128DD28DA59C94420EED95E8CE1E7BF3E50ADA51BDC6D402309EFCAA
+ 3DE5288857DD6F2581165A265DE712ECB14C88072A174972646511AF410417CE
+ 7E5152AC242072391CFFF68E909B0C234B965BFDFBE9A44176F2254DA7B94C12
+ BBFBB00BDFE22C1467B20B003E4278E77FF4FF21E78987D25C9BECDB7CC3EB16
+ 0AFC13A5C6A05D7E11B778FD0591865F637B2B63ED151FE61B317EEA81799314
+ 5CE3E4D9ED1F1C1857DD615AE4EBA12BF4B482396030382BC06BCAE522257285
+ 14F489DB7BA7EC66FB19AB11A9FA00BC3E364C395190F940698C8FC7E6106F00
+ BC843E6948175323AFB4E61ACBDFF86AE91DF51C523BB52071C645B04FA6C95F
+ B9179EA1E6F36115BA291BAA5FB593E8DE8DA27230CE51461969F6321A9B327B
+ E7AA030CE775B7A3D9D1D69C2D769BE73AB840CB2BF58727F576F701AB2B7DFE
+ EFC2E7162EAED74E96DA841115E950E561F23CCCC37455E641F40158EE7CD518
+ 7B50333EA5F3D80AC357CBEA44DF35BDB90A7CD6F9F78F7BF9146E99A2CB3AD7
+ 8B8A62D95A8F44996F93B081F733FBA05E15DB056F8112D15430EFF4C78F9334
+ 005C32BD02E9620E062D16A45004D0DFC9135412E68DF0BD2921471747876B97
+ 75708EE9C5FD0578C49D205FEDE75F4E4FD5C35CFF78D7985DBDED5E65927CD9
+ FC519AEF57209D50F584601A7AB248540E8FD31160DE5BD57C7F4DB8C18D244A
+ FFB69B72E7AC8C1CB416838A16719CF6018028532C4E21AFA9ED63B4DEEB1B90
+ 878437271DB586D7B5BA06D882D168A01CAFBC87C2080BDCA23377E711422C9A
+ B1198687D1E78796D410C1681BEE836EE6E6221EB95180133BE78C170B862C56
+ B21EA2081E5639700EC90DA78D66822D9E336F6A41086C8700381C1C1B4DA3A1
+ 7995869C5D85AE7FBCA845E859BA7E863641BBDA1418CACCFBD463DE3EC452F6
+ D66B2F8FB976E464FA378A8D514CBA74A5DE983618A62B0A4B12847A65FC59D1
+ 7A6009365B9318475F74B23ED3B5C2F42C753473058433B7F2FF9ED01E61FE2F
+ C8D0B2017152436394CE59983215D0F60A42F06C60C6760BC04D63FA91A4C5A4
+ 4CFD19F11D0679DD8017523E30E1D01E2BECBBDCD2B8CF595733640EF278A73B
+ B1993DA12CFE296CA2EAC6AAF47D81F60DBAD0D956FBA5DEA44969A02BEF04C2
+ 21C2AD37EC239317227CA1E51F03BB430498CDB6D5945E30C388589883B78ED4
+ 943EEF85D7D03713146915D5410702AE57D34AF6F082B54D691338A73B22CA56
+ A472AC4496ADCE51DFEFFF5FA86876F2510D406EA2405A74B2EF3C551ADC2191
+ 385F867797F7BA235B1E133531D26ACF6ABF4E222BF93577BED83D19C1D55C47
+ 4F64D3910000F6FAA20F502CFD90534894A26990FAEFE1014AD50D8C8BF96217
+ D73136480BAB67BA1E4BECE8F20D58227639E1A0D5B99DF961210CAE231BB4A9
+ 4BEA69F82A215876B806E8BF9C2846B7701C830CA697B3DF4B141E9F5D4239F1
+ BF11D8EA5DC77A21C5A716AD8F6BA877FE9489CE2B92D311EDC92C7AE6099048
+ 2DFD25E083DCBD555338300605C568BBFE7BB14C14587E2B18EC290B936C0158
+ 63330E19ACB55B3C7313450C204B7614E301F0FEAEAA010743FD57B99877E5C9
+ CD99EA4B4A9CB138DFA39C338F5D80A9020086E1E318EF7A940130789EFD7141
+ 7A8C67C4591FDF59BAF2C30A4CED19BABE5EF4C753349BC20FAE84F0575E811A
+ E1A17D43EF57867BFDE2801ACC84B54BD39F3AE1CF22AEF029E0C1FF743834ED
+ 8B67A99CD0ABE760364745F5ECFB274F1496C8A8AC820CF60710E8173C3CBC3E
+ E36ACAC8A4F1C9FA8F32955911938DAC1645C88D4D1D0410036032387C9C57DF
+ E75E768534F5F55A021E4A420081D666527BBFF8ED46C05C57489C7099A80428
+ 34E8797C6F869E7DB20D290702B7B64CC5AF8CA23AEBA39B3727FC330D44241B
+ 1435E36E914F0075A276E1149C37129210D0E6A465FAAFCB993A0B01661DC183
+ 083865EE42D086FB76E70E2102815C51CF64109F2AD04D5D3E922B2DBAC58938
+ 52063A68FD6D7439972B973058316FE5AF8B21D1AE5ADEA6904C8C20543A7652
+ 14BFB2E19EDF0378B88C3CCEBB76B06EC3177ADC46840BF3E33C44B6F204247B
+ 8CBDE88CF1D67CD117BA5F26A3A03F7E6189EC11327016648CD2EE9951719F8A
+ F068056AAAD112541075D7B344AF8443A8D5E3EB358E13DCF3E9BF297FDB1829
+ 1821B48609C1A59AC09332D51BD18365D996728A7630151A70CD076657FEFEC6
+ 1F802414F773FD67FAEB60F19783C10BA98DA798F8B27A460D106AAF3F280442
+ 90DAF0AFE5EB5CE2CE0406C76267D90A9BC3134D02673984ECC86F877D4B0F6A
+ 8169A33B2B121F08BDBE40CC0778FF7E6F750F25DE3596B3E6BFD685208F88F6
+ 4F09FAE3CCE2BE7363EF85A620294C9E90644FF4BABBF992A7AFF5A4A2723FD1
+ 0FFC2BD04D08945629CD25ACB3AE85883297EB0D578DC6D4012A72F7D850CFFC
+ 75A61F0BBF8AB9150623821D7D8C8204919D0816BB7F1A90A26912BB14190D3A
+ 93AE973CB3D8E2CA4A8BC1D6A8BFE11FE5ED718F58BDD7568D9FD3FBCBF18081
+ D2551BE6E04637E42F3D2A3DD3D8F8CB5C634F0FF00B2EE3181BBFA59726E8AB
+ BC20CA47434125832774463521C46A06BCDAFDA45C60E2FFD6B304CEF59D62A5
+ 51FDDE67504F05B18B269FAB5D738574AAE56874B572D7AD1B6477B889A03C7A
+ 37F20B8479EA3B8B4617ABCFD44BB877C804E25C8D16A80DECE7D9B13546E434
+ 56FF86AFC7CEEE490B365D175AA056A4C3905AE6554F129F97FB6422E8128D86
+ 434EC57D768105DE9938B2E31272F06CC86DD8DD0890AB7414A8E561821DA3EB
+ E64A6454513384BA19C410AAB8D25D96FA4C336FBB19CBEF127F1466AB6BB03C
+ 52B55864419B670C4362477E37D17DEED3A54A4F407DDD9C7E4A25D0492C5455
+ 16352AB87131F1C277452B25A7631CB85E087B91D9C883301C6AD3D4864B1930
+ 173F2A989A348A63FE43E1354A0CF32E83DE718783126BB0C26F8DB84448F45E
+ 3A9A59DC045A5DCCBBC81F60AFD7105A52D5CD416B11A8E083801924EAB2E8BA
+ 4A7D7D1E58378BA2E87629C7F71785B5724EBD50586A5482F209B1DCC3850423
+ BC447CC9D8C379F74210F161FEE4DB124C6A59648866DEA9765D96928E567DA7
+ ED99795B12B4F228FAAB1EDE92C667A71DE86F384EAEF688A4F18F0D148D3FB8
+ 9D05476DD37EDA971BD4A933A8A2245601984818FD9C0B5B7995C3509F426301
+ D61E858050B96522F5BCAE3D337510CF1274429193A9D6758832B990232229DE
+ 5500E6194B538122885B068FF9EB77DCEAF45F91E9F37A59431521D9601FB916
+ EDA7AE657B77DDCF8C815786BFB30D9B83F87FE002D1A1ADA1D49609671BB895
+ 5AA5E4975386F2B3E853875A1847D5598D1C74A339E9B5083A4165E6FEFD4A26
+ 344A8692A793A010CCEA63429F71B88ECE4C8073F7B11B70ACC73E83AB46EDE8
+ 4B187A037FD1D551E2619931AD653DA6DBE0933CE1051CE5657E251B67C2320D
+ 5BF3E55475BAD2C9B76092FA9D42663F3F87699709933447BD72AE49EA517311
+ 2DE4C46EF7A0CBE2CB4FD6E5EDB73DE88CD37881E85D4BD7CFFCCD99585A9868
+ B5E484FEB32849055549FFB3AE641B2F7A0F0F8441BC0AEBDCDD900D692C94BD
+ 0FA71714D9461B95C96F5A3B643328D8CB4C9A009A2DB0CF7E25E00F0EDC74C1
+ C67EFD4D85476BE96882ADFF4471B8B83AB857913A706CF4E85764B8CD1E3652
+ 0F8705DC07FB7F1E0BC67F539A6F3D70EB705926522BD916446F8D6B907B6A64
+ 047A7BD9AE24B9A2760CB86D3A738D152CBFCB6CD715D5DFAB6553916BA6E88C
+ F04D816EABAD435DD9E3FEB10607D1613C4E1ECE85F4BD57D3DCC7DDBF1012CC
+ C211B2E1486AC95A2C73E6D39DF327606AECB5D57C228176CA2399CBA59E5F93
+ 38999628F730011631DBD1D7FEBA2C606C5D090830A840B2C61EB67B14F4892E
+ 5200262AFC20F4FA0430402833A1526C5BC3BF644CC306417FB4454FFA679B68
+ 0D102693010CEE93052ED2448BE445C53039BFE6B3157FB374064B949519AD45
+ 4E9899D31F3C9FE2B700A312BA14B1E986F19D65657C649C59F73170A07826B8
+ 8120F5C085AF00B7F011844D25ED7E947CE566D801EB4337A5C8936325BAAD61
+ 2981D5EC2167FA36B304EF931BA81C7142FC8F7D19F4B05CEC1560A29D30237A
+ F11FC5CD3DD2C78FC6B5CF064A4B0B4F4A6CC756AB1EB6C69FC731D0ED7267B4
+ D04717B70EABEB5FA80A5FA3400F497E764B954A533FF4DAB733A29E419D8CD8
+ D8C41401DD450CD1833CA72C97701269AADCE02BA743B4F355B5D99638493F4B
+ 946FD3C2D3001E446373685DF80C6D43686FB09BBCD1D5FF956455F62E9665D7
+ 25E4918B881D7157AFAB614F3E52E2A1359401B663D43693749424DA8308C86F
+ 5B09EF581D137892921EA53FA87382E482BD3EEA2A87BAB21CABD3B36218AE2D
+ E0B210A5FCD16A3715FB23EBB742AD451D869F91769D10E3CDFA260967B008D8
+ 7FD8ADB45266B70B75BDEB57CC2446FEB75B13B665FE0AD32A6CC01074BDCDC5
+ 6132D5BF969A17A2A86F15DAC7AB93304EF02AF59D6926D1BB5B5BD975F5076E
+ 510DFE19425F259A858F03AB4BDCBAA8E20C8BC7AF22AEBB369FA70FFF23B0A9
+ 4883033CC04581B613A634A6348E83CC27FE5B4917FAB604B417A9B8E5751B90
+ 5C75DA865449B0B83C7E8BBAE83B78D1B350D0B06BDFC1E403E62CADE6BEE633
+ F6F0B686851301B810505550CEDBA3386C20F8E6D4283FA990E6144560BAE063
+ 4073CD0B6EE1A2C9CBA81C0ED110590D1C7DC18EF7A9DA3A1BE168FDCE05CBAA
+ 2C641F2F9036F0F696736673EA1370BE676612722A776F522690186B3C08613C
+ 030AD8D464771D4602BC6A0B14FB5BE8DF098E8497CEAA9AE52CFE26CDD1766B
+ 4A33539E4C1D3BC953DC693AB4CAFC09921F1CBD681B57DA1CF3FC97BA3E6C31
+ 411ECD5938BA3080E5F7CB185F2839FACA4D265C67244CBD47E505340AC4822C
+ 72A7C975EC6C8FB4677F33D263372E3F19D14498FAFCD38DE6E7D4BE0A447548
+ C5BDAE24F436846278AB79C687901C3C6978A522933579A3D9C4E1E85F5FB362
+ 05AD0A3F603FF0F41C70AB4E2C6CBD4C0121581CDA4A3C3C1C54AD23625EEC8F
+ 98FB11D5880D2E79F48401F60D64F7280203EDAA1661BEF85EB288A58A2F146A
+ B993A0F1A481815FB2D755D5F6E0E33858982DFF3716FAC4A4459159648CEEAD
+ 35B6BA6E87F6E7ED7363D30EF1EB2E4BE52B613E2FC662E17C4961866BEB0CB8
+ CF5747EE84373CBF3FEA84B960E97511D0B75D35017737C3B33F6802E5391F36
+ 4F88A9360AC334718FA9BD764D738E1B06F9775120A45647C42F14F045A6F7AA
+ 03DA4F9860400592C5AF02C73015355AF100944F63550F083FADB82BBE9C5EDD
+ 8A9D7AD4C0ACCD7CAC049F87C1F509B48AA2CA21B707D6D447D06503F1548169
+ B4235CD9B347DCFA852B6F73E4CFBF4100DC8239929C76D54F3CEF7761EAC4BB
+ 09C0F5C97D99B58130598A8E38F765C06BFC486347D778DDF6AC1890487F5B86
+ C0E174A0341BCEA5BE95522CA1FF579A792565A641483E2185544F9FA6E06385
+ 352AB9475D1743DCCF596A23F1336FF2E4E5D346A23DD9EA598F9A245FF906CB
+ CCFC721EF1BAAAFB3D391D53F4A6A9C77DD654CE6582836AE78DCA2089786EFF
+ CC3F84E14F4D0CC6EC644A1E04AB73D58A9ED53F8F908BE01299AC4078B30FCE
+ E2F2A6654C51665079539B83419F0945A473914736C0DD3BA2F0FA70E675E647
+ FB56C359385B30900A94CDFAB904557F8AEAC5547022D4E90CA850E61BD0FF88
+ DBE46A523547566F408DE838A9B2828ADC2103397948AA741ABEA98EDB0AD6D3
+ 9919FC8145DD5DF5427A6E90BADA681308AFF8CAC995153CABBE5B867891948D
+ 562AFE6DEA78AE4BBD0313600F90262E8EF11FA6B49C1EF9F9E75A5754BB2CE9
+ D5C11F00E2C555EEF394D4B2C052EF1571D6E59172FB6C13F5288692DA676F53
+ 5D39416528CE785F961546ECD72B89CF89462D864C76B2AB7ACCCCB176A14332
+ A4FBBE46E1541332286A4850AA79DB782EEC09DD54ADE20230007D47209A2E25
+ AF6B16DD39A21CDE6C802CEBF44356FB73904CAC39802A2578F74665F6F8A0AA
+ 5E915FDD299EAEBB435C9D6A1EC32865D3EA66AD3E1BB09A8BEA7E21D41758E2
+ 19F19D5A2B76BCE7842735B02548FA1EC464AAE92B6E1C0353DEED9FAA744BC6
+ 2F9C3882353666E1B8FF4AA5B391CB8F06A48A0AD72CAB1D15FE3302C555F894
+ 492D16AA7F2D327E1A92C7375B605217C3BB49FAAA3A1B64263626E2246A83AA
+ DAB1FA0A7B0D24ECA5DF3F66C627831CDC3A31AB96AB88DE8B368F469F2A41D5
+ 0F1117FA34E2D2756F4903C4FBC781B81E3B4121D4A594B25050289DEF929737
+ 4A0ADCD399963483F8D3ED15B295F863E273D70163C31F3E7A9D3D334AC5537E
+ BDFB6B2D00E8585CB1DC8D0B1E6D8487EBD4A6229A0016FDDBF96435F380EB2F
+ 5C5F697DB0FD153AFE45F743E734C5529DE138F0AD25C95DB3B1EFAD5D05ECA1
+ 053DF768DB4FB27BC1D58336EE1EAB65256F59EA4042DCAF69A2F2153A798A8E
+ 207F48280B8A556273A0E195D8A804B0C934C4905D3F3422B481C4C26BD3DA51
+ 50DCDF6030E333F07E9574EC15A8C12F0CB81585E7F93C3B0E356483E36E0179
+ C62DE6957EAC21A7CA211AE88E03BE3D8320FBD966FEAACE7F3D4367EAA6E526
+ 1519A49D24FCC6C4C12F4560F65FA0ED6A3361D10EFDF4CC4ACC69611C517E2C
+ 97B079300CCB99C8DE11226178D21E0D7D56BAE4959B64506A1107BBF0CADEA4
+ 268DB421C72478BBFA005507B1F56F788AC215516ACEEE47365D4C34FC94AE7B
+ EFA6A0EB2376520D7ECEB5212AC2D3F2B4D30C2CF717B9B061EF3E4C220F1005
+ 69D11FD03B16B2F3536C8E8D12AB90F0E7EFDB16EB1B6E66E26B1781B6DE7488
+ BEEDF3E394EB6F91CE8F60BA4BDDF9DDCD7CF1465C03C3B9763CE5DBF74AC5D1
+ AC542945DFD855CC191F1096AC9B8AFF29A126CF14A23179BA2F4637F55B7A00
+ 4E83BF6C5FEE0588CD7CE828C80D28E7207661DBF4762F4DBE1028A1AD0A51CB
+ 750A61E647D207E704AC1D8B25261CCCD7D60AF3394016E48AD0A3B5F9E2ADD4
+ 0065A6C6008639D207E259A3C7B54962F970E9F6781DD46D227A917299431611
+ 2DD6CB7E2F34652FF5A90F3F0E50679FE83F49CC0079F5770F75345E9DD96938
+ 9582AB2516FCCA8E58D8764B16426D231B6F04C68F33E3324B2114CAAA457B2E
+ F5538F3CAAEC49A1ED6F9BA57CA319303FC6B966A523C244CA0A60355EAE8F68
+ CC0F3C6EE280DFB8804AB1FEFC92EE790FBED2BDCB81201289181725B21A65E3
+ C4851BD3ABEB36540621155E81B58D9050F91049A6C69252899E5338DCEDE506
+ 64392CD2C6529A3A77E17889D5312EFB5A2F90A50224B21B71DCCE835D0ECABF
+ 666C9A929684A70781CD137FA9F9A699AE8E006324AAEC7126F4A288B54B65A0
+ 0476D964350E27C9783576342605BA8926578AEAE351F5300BCFAA0018292500
+ 893F49D2B86F9FAADA73FAB0A8B180A96D7A34C9B901C84D9300655F5CBD2F0C
+ 41AD9E180BF589DBF3871EF2F0902AFCBAC679BED7026E82776A2C1F2512FB21
+ 2025D781E976668FD796CFD919B4A3EC0E317A702AF5707AB6B431DFDFADCC21
+ B9AEEBDF7E7F22009155A6EFAD1DC3AC1A1D4CD41F3FD867A72BE03CB73BA5EA
+ BABCC76EC324FD5444FA3FD4453585AC683D4ECD3F3E3D0EB704A01DD8006812
+ B4C50E6BB12BAA8C2F003A5A1F9E526E975DEDA634E914A024BF2420AED22B41
+ E0DB3FC08360FD22732FDF4B3D4A0C2DFE90EA69497669BD832699ACDF7FB4A0
+ 183D469C31F0BDF6854F65C839DEF08339C35D7E734360A0A7939BF66597734E
+ 321DDDBA3C0F233D53620BBC8075B082D77A133A51907FAF5FB8787F3BC157F0
+ 03547DBF813B477ADF724CA09683704A94FD5E0E8C420FF273CA26B6783B7D8F
+ E4B544DD54FA57D615B990AD6E9C17A1D85C060344A8FECA828FDE3F06BB9432
+ 4C221CA6C00723953242AB61801B25F9F93F59BC2334E26827E537CB996BE817
+ DEEEEBF63AC6B7DB3613EED54B3715FC83DABA46CA1598CE9AF420D356919E32
+ 948C6BD65AA2C6F09C2C302C5328AC0811BF9549156ABCD42F24C26E45FB413F
+ 6265BFACB04FB4D5EC2B20E8F165FD99C6E54F6CE07F0DEF87155320572E6BC6
+ 1CB36577E3FCCD058F19E4784AE5B05BCD823C1F4B48360B6D600288A3235592
+ 406206920F40F1107E1010535284A513483BAC841D80990E19F99A073CF2940B
+ 7B6E61F9A20B78113D468023F9FE7F5B8B2CF2F4B82DB05D1189A5CB286B7866
+ C5EFC326FDC975C2FCFB125DCF6CE5D5836FAE7F661D731E0FAE1559A656EE60
+ 8EA0909AD4E8969546E260BEDF60244BF7E01036B7B89A38088BAF43A41584E2
+ 584ABCE25352CBEA09B071D72A0621867A9AD2F8A451D2FB87779D5820580BAC
+ E008369E19C32347BF1D4C6FA9719940C1064B5AC7F4E71982524D926D9DE5D7
+ DB73FF4AE22C8CCEDC2D3A370E0F8217B23EA40F67C1FBE8B929B124B9373CBD
+ 02BAA22F3967C40ACF692E7E29968ECA3DBB336571B120B09DA6CCF7D845FDBC
+ 591797FCD09F102DE47D8F59180E5CC1E66F855EF81A2B5A3BA37A0F52DC9326
+ 9F67E99D1345D2BB934CAC167D6B7588796549C1F86C43FC9F610F1D1D9DAA6E
+ 0AD352A2A61DE1548009C0BDF4039C9A93132927FDDF8AAD89B358AA01D458DB
+ 8C8B48D7723C7B9162239F34175DDE2DB4A1353D30A1C1611FA3BA3C42C8B677
+ 16EDBE82FD87224F452A63D7A03BCCE53181519A1670418D1FBCFBE1924CCE3B
+ FFCD1E45FA20A0C59C47843509A28B36F590A244A5B021F9C2E76058747AD032
+ E02DD80BC9EFA93779F09E01DAB84DE3C745CA3AFDE453735DD32E4B1D10E410
+ D8490CADFF3577AB359AE49DAC0292B02356C1C5F432D930AD7D8216C0EE7F3D
+ BA76EC217D9DAA09D66ECDE8131F94EFD187EA5AA04EFC13FA1674CAEEC7C2F9
+ C944325522AA1B69CE294508F614FA63DEBB11DB6B455440CC7A62C729875B0D
+ 25EF8793EE22E36BF3A3F028BABB6336EC342C2D69D124D83AE363262953DB20
+ 97ED4C77286438C6E5F63BEAA697E4A5CB6C3C5AE3F5A42430324E8915F59B87
+ BBD3E12B67DCF050B7332A6F0938E72E80B650CC2165806605644A788B4EAB7E
+ 723240631F468317D11B18A542A5E3EB718A8F118831CA728118E7576EA61A84
+ 5F2831A17DC603A8ABA6BFD8E4B08CBE565BB3C0E103FB9525C76A2614555D93
+ 3D1537B3C8E990292C12482FE9E3DAF06E30483BDD1E65FEBFE0D0E76992FFA0
+ 550C6E110B8712B7D3452F8DBCB7AD91A8F25DD70F81BE7306B7736E11EFB269
+ 14AC195CD4C67DEED023F9BE658806C4E954888BC93C4E85146F5CE8C6BFA6C5
+ E7DADDF72DCB444B8D589E2BD7CFBF90C916D4680560CA5BAD2A0251F435D64B
+ F7B32B4E5BEF79E594E4A829FE91D56C2ACA4E0195A0CB801F75AC215AB359E2
+ D8F7133EC238512D43D9DCC206313029AC22863D3F814DF60CD0908D7BA50888
+ EA5D793A8A5461FAEA2777D87582FDF21D4AE5FC77AF90E70004FE055924A487
+ AF3E67B42AFAB309CDC514B2E768E6FE8837217B1E73008AC23FA71FC15701B2
+ 430139493601FEB2BFF6728FECD54CFD01E6A46D4EE8E41438C62DEEF4060DC8
+ A89690F9158E128895448621D5EED4E37BD13AB069C7EDCC59262F8B1DA6570C
+ 745422CF586AD050F8C9A7C937469FB970F68192398876468E97B42CA45EBE15
+ 2539997829DEEF9B67CEE591FA1CA7C6AC6A274116930B9938EC2A53424FA9E5
+ 68044088EBB5D0E6852376DDC4BDDE1C2524C9A6F6B5611A78D33EEC9F79D0A1
+ 3BC4E47BB438BBBCD5ECD48954E7A12AEB9E4BB5C27DBBD58F84FFD7F02792B8
+ ECA48901DD26A46EB96B972C3E7A8DB4B800F718172AB38B9127A0B8C2F2080D
+ 01FCF2BCB2E2596E4C0BA7C74645167001AE2D8C150A42D30B1C40D72D2EBBAB
+ 45E62C36421B6DA33143FC4470875D69B644759412A36DBD669057B7DB67914F
+ AAB851E571F82D68AB26F29955148C7B0D844BC6CB53C9D7A31A3CCD432D70F3
+ DE6954B07495578F64D1908B403F29B56D56F5289EE25C231CD0ED58FA180F05
+ C411CDE40DBCCA65D560B4FD6231DCB8CB8821B260E2B260F017EA19FCC4155E
+ E1CDD9AB97948ECFB2D22CD11D0402E15F17C8ABED588499B58191A945D38638
+ C06B19CAAA875B26C570100E4FAB6AA1C3C267CB745E4CDCB9727711F8A59036
+ CFBC3487453D48B81ECA3EB4158E02C7136093257439794D437A4AE7CF8ED113
+ 81068578B00B5AE3D6773E5BF075EBFBEE1BF4A79C9CC4D7928B465BA2ADDCF9
+ DCA74AD67BCEEDEBD401FBD8F6A2F73692613960D228296B5546065876139ADC
+ BC02B80DFB28538C62AFDC46C23C4C101A7A70B64934ED8E457EBAAC9E22F7BA
+ DCF2D01C79621303B157EB374012097D607F9DB1C16BEC8D01A019C2BDCD2540
+ 2A6192DC58905E73AE537885DE9CB6B89F9C8C84B23DAF95DF76E356763096B6
+ 920899CE60ECEED24D5FD90A7EBF92F4509B93B7C44CD9F8D2BCDED5566F103B
+ E8F1530966CA963813365BC8F2588D1B2D1CB6EB19649E13BEC0D88898DD2BB3
+ 0E7F66A35019B057B6DEE683C22D92611074D714B2C4416FE521B4379F39BAEA
+ F1389C73D3F700C4C1E1CB5D2A3E3DB5E1FEBF7D0E778DA2E2D3440F108032E5
+ B3E59D5879042FB307FBE22F3202F07ED3C751AF30D254CE80B1C88C7E8102CA
+ B8727DC2F452AD3B90A17847F07B0BAA1B37159DC84D7B040341D7E1C3AEC0CF
+ 4806BE0420F1CE1BA3080E37B673CC37E2AD719EBC58E6F959127E5D50D69929
+ 8A816969C3F9B19C32F788424497119C1F1A266FEB4DC536A14F362C0E143AEC
+ 18737958AFB70018B943830D5A11DB7294BD01C99F2A69E618326D9CE25BFA1C
+ 07F23BC65AE6A43E454B43CF61559ECCBBF524965062AF3EC7AB70596AB82436
+ 26CC7CD009BC6C4A34A7B76B73A5AD0B242AA9DC3D6D84F97EA8CECF522838AE
+ F02EB4CD9CE997C55C4AB706377B793BFFBEFE8CC20F5D9A765A558C66A60E72
+ AFD676009FB429CA86FFEA4E192E5A4EAF9374F2EDF56C64F9860BD9853DE711
+ 52CE41BC70BACA75A033AEAF26B1FE01AF0F747E1C004C83E7A5241E8C52E9E6
+ D8F409F95453F23BE62491184CE7305803B157E073ABC39C1C338FED6EE86740
+ 6015DF4D26D52FE635E31271ED54F352A5066A7E8E68ED60B549FA4B9017A6B5
+ 8657DE061E28C43E443F2C898A55AF915F31CCA62AAA4FE51C6C4FDFD19E9F2C
+ E1D27A6A256A73667D799CA26D427DDC3724372692A304FE012D7DAC22996B41
+ 35917EA895F410230FD380A4D556F33871372580A6317F6248E5D92905EC2D50
+ CB7AB64DA92E986B3055658826443F97B7EFA2F64AC82360CF0C5BB5F87805BB
+ 9908960A7E3DEE2D173E6E836FC322D456DD932DC78CE4053972502D257980B8
+ 39C3121B5BE8B05033B602F82B514CF8D2F11AD0D03228BC9A079A5C99267F78
+ 120D33F70C7F1558CBF7F3C1122222C208CEFAAA0CE8E1725AB24E9DE31E2A92
+ 1C2300B01038A4ED6893EB4767DFA899C3CD2A06F33413F4D0D399D592A3C8C3
+ BCFE01C8FF79E38028B1ADFB7D7553168EA5CBC134352E189177C374D6C84815
+ DB69EB18AFA27B283249D74178655C86386E6ABC00FFAD3F44BC9E125A103003
+ 9B35D838C294C8DD8F0378ECC192B3408E5715F66B6A907719F1B10720D9D380
+ B6805EEC2B9503186311FD4AAAC2A0706DC824DDD419B1FADD0BEFD7793ADB6C
+ 7EAE0B8948F5CA37D70DB10B11A1773940F8B4C90D307B1914C4547F8D8B7428
+ 93485EA406E1D82F79977944B28F97C52CAC516A7B19F5443D32DACB70AB302A
+ 9F62E55E7EAF544F3DFBF9D2FBCFF88527F3DF5C8F5EB4828D594C5D03C0B278
+ B52D33B608B08F4AA14154583E8CFACCB817CDD24887E6A0903EDE16A46B2E50
+ FF08B7FA08C7CB2CA34D367C45ED618B976043CAA29721C2527705C13B15A988
+ 140817F436B5517670A59C85DB53AF77407BDDA580E1D3954A49DA2800210BBF
+ 673EA61974C51C4F40A8B98B48BD7B8A9EECEE57F8DB4472D55AF334050C766C
+ 241D2AF8217F784008488AD99C799A5679E10DF8AA1552C939888602DE0AF22B
+ DC385265D749BB76B9963DC1911DAC2B3E07E77A76EA180A1752C4BB83F2E521
+ 948D11A6DE5884DCC19BB357594ED150BA5A977EF339CB2B4D3737AAC5685C23
+ 17663EBE424EF4C3556ACCB485A48FE9C8BB7A85546E6CD28947EAF4211851C3
+ 533FD866F402674D1BEF467133E8411CFE2FE70CDCEA71E7F19B0B7B50C75BFF
+ 5F45E24265A7407F52552703454C6DFA96D9110F4F622BA64FE0F31CB772CC5D
+ 9AEF134493190864443DF4C529869073C8FFC73EF2F153E68FDFDDD8EF0A9AFC
+ 7AA166B21A6DE3247B55650A0252749B7CBDAA23F28C116DA1C139BEF6BE51FA
+ DC22BE77DAC284A845BBC0C7BEA8AE1CB365770093E905C4F65C9AB8A6FF98C8
+ 432FF37B81FDFF020607F23532A4B930981C1CA93336D2F6D0E51F6053B1CADB
+ 6F10A17D11BAEE36F50603AC4E0003D10338F4110119698DC00B164403C86118
+ F348182680DCC826E67793FF2934EF97114D8A4B8413612CE8E23FFEDF24F3DA
+ E7B4384E0BDD0C4495F56982BA69B73F20307FD5D152F791E6229B4FA564165F
+ 9FEF990C2D1B2847E2FF7368AE6CC10F1446F73AA691E867C63C71ABFDF8882D
+ 122BC46E4521990363DC25BD31C96732A492FFC7051F08D6BD18B9A48EDBD4C1
+ 0A4BEF40B1C5E4FE5C6F114EE86BEF0CFC88433D5DFE9E99B9AB54E7E827AE9F
+ 0116E33C0E06361DAF92E01C390DE63F7E7CFD89B504694886E1618EF4768CAB
+ 996C59A94FB6F2FFA565B818B12C50F73D74C87264419609E599E24EBF04DD2F
+ BF77D61458B820CCE75E0F1930B5478DC49CF3EB534163E0F7AE23CD7B2A6720
+ 66B2001BD569E90AADAA80AAC81DDCAC98E4E1C0B686BF71B1E18523C6D3D2A5
+ C0B852E4FFA3B78FBC04DDC69DFDA8BAAC4BF35889AD949F6022AC0E41AB05A8
+ 05E919B3C9981E4145721C0A17F18F1DBD5602B5E6E3D9C4C1FAF2362C62B13F
+ DA08A8629E169E66CEF5986680B89DED9DDC6A90FAABF545E3F97C3AB75C4A5D
+ 6997D7D29CCC443E204C85F3B435252E32CB8F8EA2ED3427AD3656A7862DFB5D
+ 1FBDA1C73C39DF2FED3FB7B84F5188ADC87879B5F65CEA55C312E96480F7C89E
+ 86BC5895C5A2A8B6C81361C11F64A2D760A2F580E93592E0C7EBD01C34BE1E39
+ 63BD06F81B86D516180A75A5CDADB22057C5FB59E9700549CA6371322394D58F
+ 9708AAED7276B8E6285466F5547DCDA158A817BC3565D93AEBBBD1BA7F19628D
+ E836CF1E2E7AF20B94DCB5A67523DAFE2C893A4A61AD75A22A1C0D487611F66F
+ 9F53EF2857AB19D4032F76B701BAD31838958AF9DC491B185379CEAC62DB3C6A
+ F8CE103E64A8957CC7C93D5453E3DF659FA641F3AE53BC383188D9F1C1440964
+ BB22759A021ECBA698DE0D602F167D7CF19284FCF346DF86B17019DB050D5ECB
+ 580165F668AE808D6BC17B3331B6BE076F743CC66135DDEE9263940A997A8ADA
+ 4A72AEC708615F9FF2431BCFD994415E74B31EF69E162FC62BEBC77B181BD1E5
+ 764947C77C837355263BA9110D331E0B879CD1B2A9EC9DEB4133F16A89531259
+ 713075E0D0F12FB5F6393FC0ED64AA62424ED4E13BC0BD543089AB23D269C3F6
+ A1203EB8CC41142649D5853927256C0E1767D5A9BA434AD0B7B7B48636F8DAB1
+ FEA44DEF33A5A62A57867EE2B5B3979F363CC9F8FC3BF0D5E2B46889DD8573DC
+ 16216AAC20BDC6F75CD12FABCE5A08725397D55F682E093D8D46C0B7DC8A837C
+ AC6058C57FEFC1F6E7E9CF2CCE16DA61A2A44FDC2DF086300AA933E189B95BFE
+ D0F50CC71C8795EFF7B9BF0C8E4727DEF34D93C3CD2D288AA17EBF3C6D6F353D
+ 70C556AC60BDA05D286B9F0CF24DEC71AECFA3DACE10FE2FC044EAC72E05FB1C
+ A96A4D27B25D80B57A53A2BFB38B6A07F7F0F81605CE752AF32EDD996DD67BA1
+ 6945D4D77CB0B597183EE23CA35FC1EEE68C4B94500D4E9B1301AF07BD670C0F
+ BEB578A2D82CB1699DDDE5BAF4D36F80014ED023052ED7EF8D6838E6C3288491
+ 6EC846811A569AACF77827F74E454C1008CBFA7712E0AE61671B06D011C85D59
+ E14327922645866F07893F5B0D780682A03DB683845968E5D214730BC18902B5
+ 863BB8C2E0C8070EA7792521D1DC307AEAA7AF791D301EC396E28FC72853C04D
+ 47D443673C2C7044577F995817040A9325F60F1DB91553C489121F1FECE72F8C
+ 4E698E7B604CF39665B7425D59240B539935A309D1715407D0623117A36EB6F3
+ CC1593265A3461CF36621DCFC8FAB32DD54B29E0F192559F116BF787DBDF1B94
+ 738488252339828E9EF62B9719F4E1ED7FDD1129C6C6333A3A7911950FA1E457
+ B395E29109A78DAD63CDB5A1463FB0CDA6DEAD82C836FD6136280E08323D8C44
+ 4417CFCDC47E94212A919F93310A1B0014D70BDCD63A7579C88292F4B7C31B1C
+ 5ED782A1C2EF116C7CD073FC0D5CA250E4A32B6B4DF71AEF9C180354358CBAFB
+ 2C9A1894EC4D57A7EE57B13ECF75AF621CE505236355691030980FB1CF32A0A0
+ 2C34E6BFE7554B512878DC29B95F581FCB65166FE19F2A553FB4ACC4E1189EB7
+ DA28D9F874F51CF24AA01B9865755815ABD333FCBFF0FA895D508F7FB561B061
+ A7F105CAEB8AE724F68F630CD2D90C0EFB5505FEB4CFA1353543C7CCC182DB9F
+ 5523879F9527DDF82C33ECDB9F1663F7D3FDF69D4F1CE9E03815B1BFEDE9AB25
+ 6824BCCFB38902C3B1A38F9A6B13B6A44B5ED7BD281E541226F7B963B83BF54D
+ C542396481F42DF7506F1BCBF63599630CD59C3A40738E9883B86D2434FC7482
+ E9899DC92628D06EF8DA8C24BE409E7FC0BDC0B6C7FA6FF8C59A695C696EEBEF
+ 1E5D69305FD64944DCA790C8D3A666FA437AC5741A256CB3C1B46448CD686855
+ F5A4AB4A4E99EF68FC9A976D6C07FE871610F76B9591D18BAD941546CF8F83AB
+ 286235314433A1FC7838AC23C5B2C0D20895009FB3F98344C4C310CAA21F5AD4
+ C5FCED00A9DCAB7B001432B87C7F9E9A6D2D0271B5BDB953E3D17FAD83F55EF4
+ 05312DAE066C904BFE5A91B961394DC2CEDDBF5F484DD4F96D291503DD99EA93
+ 51EFC7ECE131F9F0FC8CFD762F0BEDDDE947D7CA39D02F365DE2C5AC7033E7E3
+ 4670A78D170D08F03CCDF693E543522BC2B0382CFF7EB9440DC480E87B2927FE
+ B74AB44B0C1E30ABCDEDD5684819D4E9B0F8300845E2283EC9D467F77F59FA59
+ C6E336B895BB790589F2054318130E8107F5F273A9906FBAE5C70B765321C728
+ 5442DCBD9993675109DF15D640B631A049F1B7A5E8E952738AA77F5C3F12422C
+ CEE7ECBB620B2B1D1A4EE84AFEB0BFE4F11000C6A044709138DC1C59D18135C2
+ 7A20BE513F6F3018DDBF51A01EDB0E1C4A662260EF1630A4B82CBD455C313076
+ 93F27BE648C822DF8C0E6784B3F6BB7B8B0FFA44F6E3B896B81F099CC71EB7F8
+ D55AEBC06A1AD437C4F35D949C0D401DED3C7F18B72707DFB3AA828CCBCB8CD0
+ 76468D33B80EDF0A613A048645F06506994C7813C158949D41D7D7EFFDE1A88B
+ ADFB1AF2E1D18D4DABAD3B1E3E88F34677CF7176B335FB031D6214CF676CA475
+ 55B7A7796B4D75A5023415563A65055E01C0D79625F4FB111DEC72A853653D83
+ 8635BA022B128B737ED576C297B0AB632F509D5B25DE8D5B2ED17EBC534F3FFF
+ 2A13C397796690CECBEED74AF41B91185E2F6FD29A8F53B5DD8CFF4A2CBF53FC
+ 2E08CC35C0250B75084BDB3904D1CE02D60230889CC9911794499E0AB1B01735
+ 3DE36574384A29047DECE4F915A41C8B20B30CFC06FE2FB9B45AA05D69348AD2
+ 7C9A23A16937CCFDF11DA17C6CFB465845ACD6EEE769E0EA1451BCD3F6EA5385
+ 9ADA0DCFE6E5090124BD74927ABAD843D12AF12E38C06F83247169C712A83928
+ 32990D012BAA5D9C1C57F8D16BFF2BEA55197BE65CC77B693B505D27DEA36792
+ 8D247E10DC87939A302F031A82B6F3D226AF878A02B7F01A3CFA6317416F8BD1
+ DCC4BD7EE20F48CF0D8CC50B4F511D2FE384DE221E83DC2CD1FB903207F16F3E
+ 001CBBF7C2C012F3E6095692BC18C6BA8182F5E84C43194284195852B721FBA2
+ 814307CE49F9008FF1C035DBFB1954E256741466F51A1A06B80B1BC780857C0F
+ 110A8B0AA2DAEDA09AE3FDECBDFBFBA452E9C3B126D0ED0460AC4B175C1F96B0
+ 551BA7209D17D119CB0622378E91A86458FC4F0D8D33AAFFF69B2FFF3AE3F7EC
+ 17250260E241525C0D6E101146D742694C001D94C485972E457812CC9C432E90
+ 0299C1F1B7363754EC1F2B324474481DBD93C2F04F28195A5F6F58AF32DECC82
+ F991D4F5A516B448004A290B63AD108D487A9BEE8BC9AC16B93D9D7C061F2655
+ 8118EA44DBAB0024B7764A10A60F1F14E9B4204DE1B85D83C299C8FD5FCD0D2B
+ 7BBA04CA41E75A585662C0C1255027FFA2C5BA5F7DF6569411BC1B684E1938F7
+ 656D7D41EE422F93A9DE917A8FAD767A1B9C216D267BD708437110E1D128F3D7
+ 7EA52F514F8CBECBDF36D7ACD7E7082C61B011F7010B6A95F33ADE3888997795
+ 791A391C68F79648774215AC05B651E9B3BAA4D271CE60DB8504314D5E1A1473
+ 9F7C1B710D8639D07E37913E15F53D89326C2AEE97596A4CAE989D073BA0F6FE
+ 6F291EBC027F3128D446EBE2DB22B3AF36D91B494AC7304E2489896775014661
+ 63E9490DD85ACDB67578B3C2FA4DE1A1D923C105265CDFE4CDA4CE0E0541156A
+ F626EFD30FAC54D612A8E5FF726B189E78F252A44D3185F908E8BD66FE6A51FC
+ BC27B44692F2E5C695A63F7D190070E1861017435D1D6C5D8652050F90F9E822
+ 66761BDAEACC3A25509970AFD9D80E1A356A9EF576C0D1BE39DC31A68F59E9AB
+ 73DF2C7867E2582A796B1F99D782C90CBFEAD6A0A6C3C27F8CF6FD0E573A257D
+ FF7AA3786DF2EE068C36CD0ED8B06D35298F93BF97B94E3C9B314310912FD61B
+ A39025CB645A00FF32339BD2B73B5F0D2B568B3489CC5D46C9E1435E75DF87A6
+ 47BC136CEDDF5CD2FA89ECA5DA12EFF29F8C3C0657AEA7C515E95BAF0BA3FEA1
+ 849195D0B955EDCAD78FF07AC66F9DA282C5E285778F77FD780ED5948BE64F67
+ B53389E3F20BD6F8DF92727AB7DF10A21D864E4F6B28AE15391B2224BE4E31A6
+ F0264E892E7789975682D3D8FDC98576EB64B907B1BB09BDB43DC5705ECA02B9
+ 5B449A8037B39040B79FEC27DA06A70B2813382935A5A7ADB34E438247F2DD55
+ 683A2554F32FAE47A527C8D6D3D03AC313CF964A4330E3B7EFBE7C5785465C0C
+ 745DDB32CF47B35D9C4E3CF79136A8451A463403110F9EFF655BA264F6E85C5C
+ 11A5F53FD521B6C4D08D15DABB155F86ECF1878B1859FADF51ABA367A3464949
+ E171A3A1ACCFEA2D3B5E16226DC82BDA4AC11B60C408D12697C15A7CEEC8B88A
+ 3D77DEAD7C0688D18E1DFF4409921E22391FD0FE63E19552838B142ECFFEF01D
+ 96D39FD0DE369DC698A2F3439C08C0063DB3C0EE9522744DB2915C4F8B96B205
+ CA46AEDCF513F1E6B51F84CE614145E4D4DCC76A14B5DBBA1C593F320464D09D
+ 4609F44A3D7A86A1F8361A37B92B101CF7768FF88781148D885E3C9865453E71
+ EB9C6EF8743F8C815F4959EC63923B75966787EE52D2354D00C2DEAF5BDC95DE
+ 1666DA7D29EDB2C66F031A377D6DB8221173AC49B6027ACC7B46976AD51E9072
+ A9997221E98159FA9BAE00444AE6EF09B8459D5CB11E63F43DE9982B8CED9734
+ F0543C01C258FFF241F19A73E4B3A49C47921647EB3AFF056E02A30AA97F9250
+ 26FF9A4D968E70091B74BCED68A5184D953E667CC623113AB4A325CF8C151F6F
+ 89D03F70C556F049D502701C082D4E918E1910646F00CFCA08F24C07CDB51CA5
+ FA337A88B909A9E6A8844E6F3688227A26B33EC0BB7B9ED70EBC8CB77686FB38
+ 49F0B39DE6854A53E2EFE9E61362C4270573EA172AF8BAA5931C0D1DC6A474C6
+ E1022442BA09ED8177417826757F53412FCB27CE31C45887A622AE808CB9E430
+ C56CB3F6751EC3BC8BA0C3D05C2285AB8C444CEB3DF842DDC3AE382B6E65094E
+ 33871B5AC5651542573D971B3FD5CA8C3B54B644872C531D8BB5A926CDD78D9F
+ 1981B89C48FD12ED8B067B540F02A243A538D6D15C607786C5BEC9CD34288DFA
+ 88184BFADD7CE5983DF24FF8EEA0EFD1BD1E5C683539E9799DD289172AA87A0B
+ 18B200A506F264C2F14EBBF2BFB168E0F3BD37895225EEA19BB98477ABC9D9BE
+ 4D3A12A376FE6366131ECDB9CBE0CB05BA2DE140FB789613C32B167273EA10C8
+ 426CF90F2A88BC62732AA8BDF33E460C9B73B3F5E46DB2CD0455E0E511E3DD51
+ D0A98AE7F179FB36FAE116A36C36108C0FEE1DB5F125CF8AC78B55D6ABAD9B97
+ 943604E707C451C3CB50714D79FEA45C458243F803E9621CD99E7593FC29260F
+ 8E54FC5DE717B3CAEE1FB4743D6A5358242B757B386BB996B9FBA2F9E6D7AC15
+ 6CDD9B03BF53B9F229EB5D779BCFEB97ACC664169FFD30E04205A4D14F319AD4
+ 2C150661BD419AF06061E0D88ECF308CE26E85156AFB4577500453727E17CBA6
+ D47E614CFE93AB565FCE54ECE7000D9310E4234985C4F16BF70FC0EB5F60A9DD
+ 10B64321A5F4E652B42C613FC050864450DA176712F8BFB97BD94BE2008F2008
+ 55963F346CD192BDF0DE185E3F693F511D76D95A345493622F7FBA29E1BB04B9
+ EB8B956E078EA6FF8FA6728A7C477A6EF3F5349ABF5D16A9F5EF1F94CF0F2A9F
+ A5ABB3506DAF97F8390526BD6501D6E8BFA62C1B6482BD789DDBDAC7485BE97D
+ 977F68F76784168952107D3B0F5CFA9651D750900D9C08A6B81C2FC282B2FF3F
+ 2319A85DC550FF3E352A8C00B5C82750ECF64BD2706AC7E31BAF2CB7BC4FB3EC
+ 7EC52276131FFE18BAF0DA92F181CA114DBF3C760F56BADEBA8CF8D232A6B75D
+ 1101A34373C6C9C52B8A22F4C0C20269615D9BFEBAE4F7F9765EE8F62D325B05
+ 5979189A125636083C90C698CD313E93B155E807EAFA999379667ACE1168DC95
+ FBFF5FC1A1C806486678A0AD249284BB062CE4C593C2910AFD433C231F8231BD
+ 4BBBCA59AED7E2905D57CB37DC51D81C9C53FAD75CF9E8118C233A9AE43A5E31
+ A3CA1696A31AAE531B467EBA3E2DB54CCBDB9EA5D6279AB802D51A19FA269E11
+ 686DCDC5F4CC4FBA43EFB72DFB13CA12D522E44972A932E85A7588EE5DBE5E38
+ 19788596769D94C800C6CD5C8DAE45DE5668B2EADCBF7705D488A9588A4D8736
+ FE883DCD471C60F6D05F70949BA4198DDD5F155B4C0133E49EC3747AA34E5AFE
+ AC3AA4313257A5EE4210B56DBD0271348A6A40ACD43622648E29D8A39282779D
+ FDAF2463142637B70BFFAD6ED3C25D1C2A0D725774D73D9830B87BB4D690984C
+ 5B4A9AC627F3AE6207D81B820CCF6B614FD8922D2533316FE697666CA5D9621D
+ 279DD8DFD304E8F1A8735617810E2A16B38DCCE61F3C934E957826825D581368
+ B9DEEF0904E34CF09D7AD9EED85205868EA29016DD59B296EAF7B4D0BA3D9F59
+ 3AC9D4EE2F66F56F56AE08BED673010EC5B87015D4DB7B4E8E88A741C66FC54A
+ 73AAD1C15ED9F6E9E8D56DAC4465F9A21ADB0539EAC90A3130B24B7B265CAE5D
+ 0084906945C4F7F17246FC0D7E879F9ED82478F1596A0FA565E13550EC528992
+ B457E895A7C5ED16CFFB0B94721B402177D0F8B9B98AE0CEA69699908DFB71BC
+ 0B090477C1FA3B64D1942B237788FFF3C127E1966B6609BE4DCCC34570F17938
+ 42047FEDC5675CA666147A50194A904FE92C8BF9B68AA3569493A0C61CA3BEE0
+ F95F84D4C6E9C7A0B5CD4A3DEF29207BE9CE84E61E0DEF4D1861289B77B5A591
+ 072542C0D7D945DB5BED4116CD63831C94498AF107AD32A8353E83A38E34626A
+ 22F7C86C4FE20456AFD85323E0E107AD2CFB39D7D0DA0A0705C8EC598346F494
+ 77CB867A477E10ADE6203FA7AA30AA3A77AC8328CC696555D966FE646B23190C
+ 62354AAAF09B2F47DBAC8C768E6E7F9CEBD9DA9958AFEC12459C47825C996FDD
+ 4F1D1FD5B0615B44B36815CB792AC6AA380DACE4D53CAA9D8E90957148725FD3
+ 69997A2A2911C15D511625F391FDF4F01C11F59FF8F0D6898D393280AF7946AF
+ A39FE3491C57B66235C30ABE646AC8C77FCA3F2E7C3582CC78047127F043E573
+ F9FF2C37006271B0C32F9C4BDA971D2DB3C3DC3DB97A0B82F94918C167DB4EEF
+ 56C0EA21812A6B8958F2D8099CF7B033B1AE391764066A706EE9DFFA343E6C32
+ A886F5E3914192846E9DC7FCC09F3F318608FB37B6DB7EBF54F44599CF6261BE
+ 8ACB64F9B38B66436ECB366D2BCFE5F4351DFB29AB1F0A122659E26496E5CC3B
+ 72BA24E110B22571BA065B53C9FF678641E1F9C5F80EC317CB11458CF45C8E5A
+ 3AD767DF9B8F689AAA7F1A7A1FB544BB566842583409AF2EA3AB764C597345C2
+ 286BC9C00F28FB0D099E7CD923C4AE000370CED0CF382A8E299F4566AAFBD446
+ 2F94B508F386D292EEE0B1D2733022ABFAA22498D7B934153F3B82386FA23EE7
+ 711395CB91EA7C76AEC497BC7A09B4F8DCB5423C24841CD61681391D1F7798F4
+ 2CD20FE2516E9755FDC0EF16BEFC89EE4790950E9D77785E296528A9E2D8F3ED
+ 245C7D9CFA206BB01C50338244B39E0A4BAC3452597DB043BE4853CDC6352639
+ 4CBEA2F3FBFE0DBD46887DD67D0D76F4CEBE63818BB95D47F39950FAEECFEBA2
+ 49863133CC8236321FE7CB363945C3FA870DE7D54491FA3A7A51F59D0A922932
+ 703D3A6C2E3687E7A559FEAC6413536A358BE12B882D32AF24636D3F488539CB
+ FA676C8D7FAF1177DEBF000D6F176514F13C630407AC337C341377409493A5A9
+ 0EFF6156B9C84AB4874F92BFA23CDCC66A218CE14A731EEBA60CA5E518E368D6
+ DF27B03D7390DBD8A79AC3D7208B2F373901AC92D9AF3BCBB4308B32DDD46D6D
+ 459C8D0EBF945B4D2EDDF22E44AEBD279A13B3AE94330D7F18DC59F8B38DE752
+ D0A84507077FD9BA4BFD3DBC4EEFDC04FA8DED6F3E2294B41330EF67D6FC3EA4
+ 32707C487315685FE2EACCE5FC62D5F6F1E90F344D0AB21BBDD93586E5E8DAC6
+ 694B2FFF14D71946DB21CF13BF1AEAAAD3C03FE9363C63DA0FCBF63F8DC9056D
+ BC5CEB42DAF13563C7F68B19F265407F5A9CE954FBCF82CDEC41CE5152A74293
+ 2048C38D3D8F167253B443913670D9AB5AFB1F49497DEC3D5E6E13C3BBFDDE82
+ A71C91A1A005892D32C095F59767A94C73DE057FEB94FA38A190FC233AF06BFA
+ D50EB7DBF6E80531DD55135820AE62875107D491834CF00BD5CF67CE589868B5
+ 540B6AE912603C7AB304D2F5DD89FB67E0C037133B1B74EA84C0365EA03EB749
+ 4FED9C64B0B92587D304264B970D6EC7EFF8FA78AFB0581A8439A976328CBA73
+ F54945FABF7C03101B36C64EB4A5D71A1A06A682E6FC74D5F5821F563AAC9530
+ 770091F2E01E7A07A75413EFD4F1FC6515243D3372D888CB72891B62CFC6444C
+ FBBAA8006249BFBB6BC2C311C7CE3E12F2461E42C860510DD3CE80D70F8826BA
+ 7FE0D540E983816EAE4EA74A7E51356BC754BAF327F2F5F983269D96DF62DA3A
+ 117B13EF5408387A60F1D7A9B88690A4F8DF94C2E7542BF4221BB77BB94A53FC
+ C87CBFDBDA7AE674727924400A2DD43B98CCF61F167158D00CEE8ABA536CBF6C
+ 0333A35F3B2CC2FAA2731EE71E4B632B6FEC86B4A565660698D1F37880F48834
+ E212536E5CCD94792006EAC6FCAE8DE9CC743EE900B4E051D5460C2A750B9018
+ 0C81FC828A8735B4E4FFE07618839B5B0291DE8810229A8E099FAA9E3DC7E9C0
+ B814BB58665CD85AB6FD438B297B87BC208670DE99DC54B88E09C8A9DEF0D746
+ 2E1D26D27AFEEFE60879F319D059B1B52C8A163086CC573021DD804DDE44C0DB
+ 3B3985B01CB0CF68980FFE2973E349817E3A5B6B070197235A0167FBDE7B4559
+ 3C57F57714025D897783EAEEE53BC366E0CBC8B93480016E187336EF1A3BE603
+ A8BC6AAC0C09A4EE97CB9F5D13C98F9DCBF693B4AA366C8AA44EE477D5A3F6E0
+ 5D6FF3231C7453D7B4DA1263ECE83CFA1708C9124B43960748F0ED209373D1B8
+ 263ADB64C7FD673E53A874072E4ACF2ACEE29EFC9179D9AB236D65169DEE9902
+ D110535706523ECEB84DCAA991BB3BE9E026F65559197876C4F08D99E9FC8DC5
+ DB2F080AF7F90918523CDE2AF5086951C1A2934AF24ECE8F93E681DFD4F922C0
+ 0584EF5F2B9345F71BE5CEE3F3D7BC2EA1FCC22383D2F7EE03CCE8DD6919A5BD
+ 02ABFBDAD487851C862370124C5C94832A9A87044013C58673150A3C6B0A0168
+ 710DFB5E94B70224C8D92B8C47ADD1C47E376E61A291F09D7D17F33255C3F89B
+ DF76C67E4599F1AB9256887A95B5A4F5C0A5490792369678DB03F2B609AB3EB8
+ 3C3BD9859ECE7976850C0A80DE024FD752A469263C34C4BA0F7BA6EB4850F72C
+ 49F2F7AE0C2494447E024188E1A5A2C66AE00E9E1E9C3F5B6E9EB66E5DCF9DDC
+ E21F9219C2F2F35DFE0FBE4964C33ABA40C764194D85055FCEEF16ACDA4840B8
+ 6F38BB99CFFB6D23049FB5C580FC9CBB36536E8762AD0728CA567A0BBE876F56
+ 21D9A7611CAB5980A3BBD531AC624CFC5FE3A1A652C58B6657B51307861EB0EA
+ 60B801F1DCA723064DE958AD7178453BE9A85EB76335ACD9D08CF6D4A394B716
+ 199B117EA3A5B39E9EA0CDEAF907C684EB146E61256CA96DDD16BDCFA897D14A
+ AF73359BEC584140BD2BF4264985C649C31C66BB3B6A7DBE59AEFE829481BD2D
+ 34DE7C1B9BB23294DD84C25A0CAABB76ED036DB73C95C863FF658AFFFF783A01
+ 4285C2A0BFF97A503E14DEBB657E6A6B40147810030366518C1B6A557304ABE7
+ FE0DF49EE3265C9DCCC952ECD7B873A2B9BB1D2B0EDCB33B19301BB76E5607AF
+ E078C131151CEC4E5A8F597008190850536439DD63DD502A7728D8885D10E4EB
+ 674B79C5A10A4B7EA042AB6D7529D5EB5A65921C349EC19055D96003A31E051B
+ D250BA9799E169C4D525DC4C24C53254B20D7BFFDE5BE71F90B92E1E137BF46D
+ A542A2D6CCD985BCFC43ACCDB7C7DAE39757C7B2E3BBCE186C6836AFA0FB2973
+ 328B8295D3AEAA8DFF8A3823A2C7DB1A96B4FD4702F03C216FE8859CA5D7CA6A
+ 322C6642F4455E67A2D681E76E390F7BAEABFFA3D3A17AA665DA6079A82D34DE
+ 0A9DF14A576285960A4E4E1971689CF990B0ECD728782ADDCA51578C267863DA
+ A8FE549123537F7C0E4F8ED2D24BADFAD98C093AD4CC52F7306DEAE0A794699B
+ 37A87232CD3BE016A2A05F3569090EC4D5AF39632EA0C1FA216E769C48A15D03
+ 6B40EAE3DC6FCBE5AB524F2DEDC450407F5F2CE4112F1E6275E1CD79A5AC9831
+ 2FF65D50850980025E0DED96D7549D21B38CE3709C6DF295C0C15F14ACDD075C
+ D395DEF85BAFA689CF84096E1F542119629DA031E43A1B6EF06B2E4B191EC09B
+ 48DF825E8D01B7BBD414A8EE16C8019761EFFFB496C0176E704C33F763117971
+ 29AF0990333F362F7CE965105715D15EC32364D76EF0A29A6AACC5F0D0832E47
+ 4058BFE7B232868C7BB44449C3FEEEA753E2F353337E8C7CC00FEE3B12626BA6
+ A28F189D4EA3A5A2657AB26A070E944AF2EF50F013B88EEFB24B66ACAE0A5403
+ 1713B2AF2393EE604EC59CFC13BABE427330963BFCA41BF23E2F0284308D9B18
+ 4815DAFD156893A3C51748C3401AC90D1D64531FA5D63B302B998F56D62FF110
+ F0B4BF2408AB598D81DB5EB79CE303D85B556A4FB1D6BBFF4D5AFF932F178E43
+ 24C0DEB2325DCD9BAD2CB80D7DCCD8B49C0917377E56F34D579BD05947635BA8
+ 9D2B7E0DFB4F43417F29B51ACB05D2C9E489FAE16E8158218156235A591D3D9A
+ 485C930326F3764FCB2910D0A8FCB01052688BBED7F34D6FB5019952E64BFFE2
+ C5153B8FCFB53DDFEE2A42083E4DAF95D52753301CFE3F116A72199E275862ED
+ 0BE6CE346F65076E69CE229CF294738A83629A1874DA5BFEBA24618326B4A825
+ EB3A5202F4415D14FA71F1C3838592E38CD4046212C3214F7C990698E398435C
+ FE2D57BC1B95F459D12FD031ECCEBCC917075FB3BC0765D27038502051EDBB6D
+ 6C65A3E0EE841B670C83E1AED634483D7799959562AE181C6C0FCAD41A4E6CAA
+ A22F0159047D9E8F3508EE2BA021FAE37E78F819678C50424B0477FBE6BAB13C
+ A8FBFC044DEA3807C1BE84DAA0CEA59476BEDB29C5A9944B26957ECB87250DDA
+ 6C5029C1B25E52423986B8702E488E9915DD7A310A56EF2FBB89585E96EF853C
+ 2466D0FDDB0842A825895BEED398E6931C970FEABF368BDAE6AEE0ACB0FEA7C3
+ 57D8F949A489C3DE0FEC2C37C4912802F80EDF30875B23B522360D424F5C8F1B
+ 1FBA4F29214C4376D2842E5BD2AE857663C507E62CE3DFEE0BD1E26A9EB5DCF1
+ 93BCA038AD415B824ED9FAB245129D8D6B40A87C0F146E9D9F59873397ACF0AF
+ B46CBC42FCAAF8D29737A6C8F5BE39081E59955A03F501C1D38A1A3D27417904
+ E80DBCF50DA8EA1327C7A3592A1C980A2BBF51868B29457728414789A38187D4
+ 3D0619773FE35D946130BF3B9AAE4A5A6CE252A8F9456E1742F5531186809AC2
+ 3C1C4C523E2D59C2A22A4DE2224E0C1CFBA502B181A5A94E8F9271FD4BC542E7
+ A277B5C810B722C946B0B1C124AC9B47B04BBAC44E22CAB0463FB86C5D83346E
+ 1B450BAAEFF6E92B2A842A3A2B3443AEA5A9D04FE8B368628D798307C0C85D4C
+ C5D41111625E1C90CAA006A09A34AAB2F967DC7908C328903DB1056C31F9B2CD
+ 66FAB76DD7AE4678D2F5216D01B9F46B150BA513D18AAABA8F0E9F8DA9EA2673
+ 8E587CDB9CBE10BBB34439A099D839D44E1A73CAD016D7F6E029AFE6E3B1876A
+ 991B83E4D8FDE0EDAAB7E5E430EAC3BCCBC0DC952BD5E19161B4DBC63AB01C6B
+ 436D4937B1441F45FD74C0F3FEF37D3CA793282F71ABBA57B84F439D4CA65449
+ 9871196D1C0B08C7CB4E3B843CC592ECE22205742EB7DE2E03020B3CBAEE3459
+ 1A983B29EDF8AF6F7099E7C8BE9F959CD913261B6B24F291F239B188B1F3CE95
+ 376257B23E5CFA527363EBD726BA8BD55F6FA3F435A0B8DAAFA5D30623021876
+ EBD17040246A1B67549AC2B8A79898F741C40EE4B5D4A40620CA49FFEBD0238F
+ D6EF5C52DB47C753A63AB3B304331CAEF855309ED5035E02531D0115C7B62C2B
+ 6C6059CAFCEE6E7F7F61FBCDB8B978BCBA9CF4CD6C62AEA9FAEB10B70F949351
+ 4FC4F0B0AD009D3A25EC9084DD7D5FB3AFAE44D545FCB46A950438D8463037C5
+ 254106583734B29B6072A0A03E8AD87FE514BD71E8D3EC3EF030DADE248FBD06
+ 9A4C9728D8B1FF11A785FDE2270FB427EA1217C8DE0FC4A12E703A3DC9D815C4
+ 3F28B0BEF631F4D1C48F603CE2ED7D2A198B800280F5F0532F689BDCF1F2D07A
+ E749E60187804D5734A0B67144EA88DF06E0E7DA85E7A39CA080D20942A39E88
+ 43D0586FBC08273B82FDE4504399CA6B4045801916E3910147457FA3DAB51A97
+ B1749A966C463568718BA4328D6EF2DD3118C54A17D2354A518F6E2873FD2612
+ 0E815C3329068656FF6818330D1FDECFD76FCB6AA33F79D88C6DFAEE9C9A5B2D
+ 1346B532738D06F48E32FF5E748E9AB94369F9966AEF18412DF1E97F6EBC788C
+ 56155AC129E3145049BA38FE9242BA51E3A3CBEAFF4D0AF16B0EA45BFD7DAFE3
+ E16FE75D07595797239FAB10DFAEDC0EDD1286B442E073E873BE94F64F3BD1CA
+ D5DAB5CBB8B92BF15C486A087D44C574A5CECAFE2A252AF563B5C3DAC63103C7
+ 92466B0EFAAF81EF40EEB534759B3B2D8E03C5D99680CC75F03954690467E51D
+ DA1FF3F92A6CC678F757C8DC5FE43FE59724DC6D284C9047FA06F21DFBEAF1B8
+ D8DB95F2D6B8860C460C4C4C1045ADD207CF5621C4E916A3CC89294DF65A635A
+ 8DBF007D9B25E491E0CD3BAF2AEAC7D3BA971A47B4EB9A72A0B02468D5860BF5
+ 57B4165B3AF3BDB58FB03AEDC250D77D09C49A6E5059616DA62679847285A2F0
+ CF6BC31B4909755735C4352F6C3777099DC8E51B6D8F026AF202CC90687EDD17
+ 49B2DF81C4621DA26D4A1A1399D51A98B510F90D60513C0722A64F5A53913B30
+ 63F89CD31E18656B732E4E81A87E7B1776AB9DDE5E3D0F41D6BA4A0D14B53ADF
+ 0605C8D10149A59936FC84DD8F788F5AC896778011B6667DB23E5E0FE7A46E8A
+ 74039A5EA075A8D679A2EBED420E106BBBE907801C578E225FF772F2C32F9BAF
+ 378D2E3143164A80415B9324822A2594E0EBB6E7F941ECF14CA53CA81EF22013
+ EA12FA3113B7564D7349080D8C08AB8FFE7A80AB9B0C0482C1F73329CCAA0D98
+ 251701C435AC368DBD7232E1DB3FF66172FF935F87312A8554E27B5AFB33DD8C
+ 89564F83FB0E80E912F9A4BDFFDBC6C7E2948B320549D926D156BE9D4C0FF606
+ 6C81CCA96BF936B7B1555067141BA7C3542FA8257334DB13B68F8687CDEF186D
+ 1CD3C390D16203BB88BDC16E61913F7E9C657BC461BEDF9470F9A07029023CA8
+ 95AC63D3A2C01A789AD7BE312B694A9DF8FA0C03B76BF5A7F4683D2B09BE8D59
+ 632E837033819ACBB1BC08D22A4381CEF0F64D7111C701359F58EAA16B9844E7
+ 2CE437A8FD16DB4B8259389C8A62263515579D2E03C6F8038A74DB1511216A2F
+ 332816934709D2F0D3FCF407749C23333FF56B2B133F38BA12A54E4DE6A582F7
+ B479E835A2B0879E67ED586666336F15793EB139AB7C856365D9E9C6B3782B14
+ 42807040D86ED0EF874B4F6A2B1DD8B51A0CE51F64D6EC14A0ACF8B5E9C19089
+ 61D95AB1E9AB0025D127616DFB040721B0660703CE330023B73FB9C3FEA2A79B
+ EA77AC7D64AADBF4DAF5471C401FB527EA5DE65E7D17E3E6E6A511F18D927BD4
+ 308D57E31C166B966F96E1E7251658E5E7B44232935DDF5360AEE367128B47B4
+ 0952E396E973845696D8606F83B57E2FF7737E35F796C113A01D212A19B747A6
+ 5CDA74D2DC1812E70998EC85651A31ECEDA3E467A57C19ED398A95210A9F512C
+ A44A6EF5645025BEC372B0D487832D055855EE819956E72E5C28F92D8EB5C489
+ E5CF82AAB447B71901F451485541847095F352F5FA71BCABCEA5EC3A450913CB
+ 022E72FF60F46BEE6F823DE0FE9343D41AE914BFB0063F854900CA8912690AF8
+ 54AD4CD12B58E0093004362439D392D7C37C5484E82C0E977BBEAC23E7DCFDF5
+ 7DEE36B68C3752A96BAE54BA9C55F0063A5F210FA222B032455996F3B47400CE
+ 14EBD9F5822352B6F1AD96C0C56F13D9C385D313D76BF1E12ED992201BE270B2
+ AC1404D2BA6ED7C6A894FC4161A17680ED64141E5513B567EB60C4F9E6DD0FC3
+ 5DF61A378CFA10B7FA1DA0D66B8D7D34CDA6EE4B0E1F93DF87DB3884EFE74352
+ 6E413FB01D0A6808A56D9211CEB45E8B0D0B6A6B22739842DB70832DD47EBFD7
+ 147F5B5422A8134DB9C2F81DFA16CB9F024CAA22F9093FCC6AA2E4CF2FC20892
+ E3989F2C2649B5C39750E5A39CEEDECC4F07A40DCC8264D0C14C2B2C56F1BC82
+ BEBCC7EEEB966ECB3ED89B61DE3915097CA896774926FDE3C12533536653655C
+ 984503A25E03B3EA7D80628F323757EB9E61F04E021F873D7768FE2174D90159
+ 4D2A7E1224AA6CC6ED48C75E9225462BD9B8F2FFD01E61A798BBD3A7168EE2E3
+ B25BF0F021FD3BAAFF99C138671B916F7E7029964CF8CA090C9E931FF15893FE
+ 00B9928F2439C33F9C481766B901AF4856A9D636835C82C2E8D8220F51062198
+ A9045E1BC71209B9F8094197C3C4D83EEE3DBAC37F66B46E004005062730B974
+ 916A8E7EEF1C5FAA29FAF2020123068A0ABFB3037EAE201E75299A5B2E05DCB4
+ 3D2DC360EA36BF4EE2BDEF45A8778C5185DF89FB3655B4EF502E0ABAD15DD4D7
+ 9A5A62FD42F8CFD34BE03F9BEF09E025AC89BA8D397240F183B05FF2BD7E8B9E
+ 7B1B93DC09C4D1A14CC08213E5E93E064C7EE2948B1EC6230D4C10CD8ADD561F
+ A1E95E3456282A3F2FE7C764D78221BFE50712C577DA522BBF5C1834989A68C4
+ 5E8BE5B14A4AB14B3AC83B0FB495CC32B1B2506D7D42EDAB4B5FEA3E4EEB1617
+ 70C85245C58F1D7F7BBDE5126FB6521441335ED24B9B1AFE51D6DDF8ABB45440
+ 2E8829FE6DD3C16B54DDC5864E63C4F3BA6C4A5C22136DB12D86CE00E553DEC0
+ D8D44270D97FADA93E779699BD0D14F6A26401072C48146319DDA1545DACBDDA
+ 8DCFB205C587710E2D1A9D37959EE7DF9264B5A25D6CF6E318254D3A8AFE0EF3
+ 649A0E28F8F8A7BA3EF0D8AE8D95F770FCC2AC62805CFDB63E36109181E571BD
+ 6A4AC7CD9B84325DF07DC1F14F2693C968F37C18A05C5D1CE629FDD3FAB4F607
+ 3927D61DB9EBEE4CE358F1A364EBC8FED8013D800C658C4DE9FECA2244ABB991
+ 273CE88136280839DAA02F681F014534DF2A8769331242E6C515BBEA78606ABA
+ E2E13BA34AD042B01B4B1DCB2A9102D784DD8146D54C628973F11BDE1B0AA8FE
+ F901675CB28149B85E37ED57593DD4CC5A90E0BC0AF86148633FCCC3DB48824F
+ 3061D1616365CC407E742F4E3117EE0F5951FC27EFD93368E0CDBDEDEA323E5D
+ 28729E6367AD568FD58F9CA5EB5CE4C194178EF820A80365C38AF53DEC79CAA9
+ 831D29473C7EA5A6177DAD21C543604CCBCE37B41F3B4D50FD6E0F45141B5A6C
+ D495B7F05E57A1D4A09BCE923F15356EBFAB39A69FAFF28FD5508FB0ED14A755
+ B2D03A11B1B4262ADC03E987926CA999048F844A29B43629307DF83E6BC5C789
+ 95644158D09B9EF51F39787D3D4A967D0BAC0F06A625F77DB489108AEB67BCDF
+ 5DF2E4BA907C4CE5932161E58561B986B1D02DFDEE3B0D54453E97E9146B043E
+ 0F6162299CB958BC4E5126FF22D99EC1B1B998525DFFD7D69480698CFF22D101
+ B2083F5B8374116754890FA2CC24D8FBBE5C37209B3934EFED75CAAC3C966E17
+ 5F79F76CC8CD5F2C5C7D59BFF44A825DB67CA283D1DD03E2AC51623ACA671B17
+ D535A2DA71F6288DC31FEB29885663EB23CD844AF7FBFB0E0763D1E250FC2D5A
+ DFAAD385B40DD20534187F1FEDE7365C23C32AD34E361139BB664FC16A900461
+ 15957FB58A4B7578543933FA38F4678FAA37502A75BC47A6423656897C6A5DC4
+ C8BE476CB36335C2F5B13CFC5CE9E0BB8A60E1F4754DA28D9CD1FF362A341FCE
+ BBE04B9EEC531F6531E7F0B75F36E82D4D8ACBD7EA4EFAB98B4FA08C8050EEFE
+ 024F20D0AF6AF3244F5F3A801F5493302939486028DE196D0DCBEE1AE69C6B9E
+ A044D9323901ABE2BC08AB60C3B4C6E40AEF3912D4E1FFD6A89D90D9DED2672B
+ E427405E87A0B499D7B9B04AE472D9AABA2FDBDAB49C84019831D9209BF318D4
+ 6258CDBED161D9BEBAC2E481449CCB49541852B79B5387FAE9233692B9869647
+ E441B249989416989EFAD74648783676ACB8303218CBE4B8F4DAC527AD17CB59
+ C7C11E2A07D785458D46403252045BA361914F6705C27A22EF9E1787077184EE
+ 87471DA9F774AF16C9500706C1E5DA7AC94849ED3389A14D3686581D07A30283
+ 6E18228917144127B12DDBE5449BA8A9785ECB5AF6D50A5010FB6B8B277F6ED2
+ 40FED508FC0AA948CF6EDB008E11B1F5B1014DD8E5181364E5B531C23061E25D
+ 7EE98423C1D018C719B2A3A3212E441850443C1FB07F76F88181BF972CEBA8AC
+ EB52A17BE6B99F306E8781805208D9E336BCE524BD25CDB3FA6027EE029846E0
+ A0F3CFD1E436ED42606C80186EBC9B30BBCCCC83871FF30E8FA6C94A4C69D919
+ A6D539C3FCC33A97EB734B367ECE4B6648696FDA3006ADB60D617D31A5B1879A
+ 5324B30C8B5D6D77799705CE160ADB5C20F052D802677D0927F14FDF9EA91414
+ 43943D59EAB7BED23CA60FCF84970F0F77AF974CBC2ADDDF2304AFC4CC71B117
+ 1A24BA7C48EBADB9CA10213C874C7B95801830FBBEAAC445CC5724B5BE64D90E
+ 754FF44F034AC9251B05CBF010878667DC8BAB28A576C56FD046F9D9BEDEABCA
+ 8C3C9A8961B92A6D2D4056F4A9CC39299B4C21CCD1427316D35F126911F24DE9
+ 010F048615D959B17FD3831479C18A5FB1F10CCB84237D02534A10FF716DDA09
+ 6F8FEE288098ACAD2D2461CB1D93C137AD08538FBC47662F120BD29907389C7B
+ 990D2D76E39D55364C6DF659F7450EBE1F64FE11813FA8477ECE11BB02E7ECE2
+ 5C869F9E722441BAF4C703F7FF5E3211B5E11AC4FDB023A8AB08AF7FA9830037
+ 70060858C7F47B5B7785BD839B77288C88551CA77F26A43DC5DC57ED6C53BB33
+ CBEF456E4E80011CE5E465FB8C6DD14BA18221610A07F950AA46CF79DABB832A
+ C760B2AEB45B474009ADCE0B315AE5B87B4BD762D1D88F68A0F92BB51CF144BC
+ 31D459AB1DD3091721C85A8415EF118BD2EDF0F2AC4EACC24080CC2F6609F072
+ DF5E71AD0FD39F62A4A0BEEE239A9DA30F6E7249459329A57F6805F1D4DB86AF
+ E68DE485A08EFFD9F6D3C34ED339B7F56D40067BAD60A6A3176C4D68AF44C010
+ AF3AFC87C7D8BDE4F451BD1F801B79ED94BB32D81FAF8A92411FD1D119D780E3
+ FB848D98BD2AC749B4DF7F8736BEE8079C557C75922E35262804DBFCE149B975
+ 6CBF9EF1586513113896FD750B0FCF7BFC3E59C05C7676AA277530428BAD0EA5
+ FCCE202DD9DB8789A31C01A9881AD22F17AF0F366A11A6D692ACF8F4F4690CAF
+ AC0E0FC371FE078E9D3D3346511B8360410979C9C24A80C9E0869384E385990B
+ 5064EC2591D6EC571A2D13F326A783A34ACE17D7961BF70B8CC008CB13703E8F
+ 73AD36A0B9F4C0D1499ED431099BA14D8A445B6212B2614BC780746DABDACD38
+ 06B3B4833CFB0F9A13C0F0D5880D36D875C0BB67F8CBA206C85CFB472F4A45C3
+ F1C8C6D6FE579F88969B57EEFD0C3F12357B6FDBD7ED47E71CC4E71CEAFCEAAB
+ 86B9AEF273AA33B27704294B4AD120D1BDD45F855037415EA3A0747EB26B53BB
+ 4434F7BF4DF11D40D59463CC1AD86413F38667D047AA3C2626EF91BC7E15D997
+ C7524F2AD8972CA9917177DE876CAFD9EBA38A368D1D5BA79EEB2703E67C4BD0
+ E4155A53F92D7C0AF3A1FC8B7A125B9A15A867793D20F294C9D1867DE536C364
+ 268F16B6CABD3EE553EB696391CCD18113D9324CA438D44659F202B6B1BFC677
+ 2CFAA1A4F4225B5AB9057290F4B7476027B61348F2B8FBB3D062D02C69E45E5F
+ B167BE2B8860F692360475766D6EEA942F0694E137BC42B8B99072CE80EE6B2C
+ 2AF0DD9458FF851792B7EE1DC99EC2A500544C38A48D4B61AE64A7554E493588
+ AC4A05DB05D37FEEFD0E146124D4813294E197402A108EEBA67AFA7E0022D5DA
+ C6AB25092BB584AF1FB1202BC1978A89410CE78C5399860581584A8812FC2677
+ C3CBBBEAFB7CE631B3D5BE294A9EFF7A8C9A6300D0A1BF938A19464E7FAE1076
+ 0F47DE0F1F01B8123421BFB67CBE7600239E983556A4E807588AB5935E650ED6
+ B2A08C8669A774AB693450F8687DA06CBD7B5A9C16178B2D72BC90307C156D9B
+ 6867A1C0CEA433D91EA67B7CD301710D6FEFC9128D035BD99D156885B4405C77
+ 5ACAFBA174D17178CA55A7EDC883DC379776905A49ADDC737C2FD0102A774237
+ 1C0B8957106791A926C8B32971FE4BA9DA0984F83D4E8887A9DCBAA33B9E9FD4
+ 40D7BA5D25C42E94886D387B34941F48468FB52E2FF48E07D2BCE63CE25D13E3
+ 14EF96995198B3D88B906E9D0209B13504ED2F4AFB3E9D226511B5B2D5C800C8
+ F041A8EDBFBA891F58EC9B477C7689C75C03EAC1AA1862F923D3B874B1521925
+ AF0ECB34E9A41DFDC33613A1B2BADD639DA3536A7AA17C677C0038BB7021464D
+ B6E336569DC894A5794BAC9439910E5947AF74C7D68F5D80AF57E62BECCAAE66
+ 7CC7296AB32295D18C734D306EDCA298A5F0B34917FED423E8701D6CCF5F0F43
+ BDFEEEC361A020E69A08EBD3F974C4075D49BB55D0AC2F223EED87F1EC7D8665
+ A77CF3C9B6D8DD5E048CE0044ABC743521944C881E73818EB0EDB2A74A3CCCD3
+ A26A455DCC428AFF629E7F85ACCD8B0DDD54DB3D3CF62945511A7F9C6B573CA5
+ 27BF465B592FE080CFD78B369843031A52178A6CDE7AE610761F1D2944EE995D
+ FFAC35489196D1E33A272334C771EF05B05A78B0FFBD9A6FF9DAE6076D88E3D9
+ 440031556DAE480A252DE4AD9E56410DC21FE5D3E39C44079E7954E05AF2266A
+ 171FA1BC55DCE9FD884EE78FE57DC7776E85FAB87DBBD81C122DEC3C1EC8A059
+ 4729E87CB3084E1CEF2C22560AD5278B65C1A3FF6E2B329D2EB53BAFA7D8E388
+ 3B90D510E817A30862118582AAA8D6D7949B823FDB1D76516CBDE2495985C8DC
+ 9BE8E02E373C3026EB88766FDE204EB5FA131A10B471C781554368E2EADE9123
+ 88E015753BDE4F7C008105B56EFA9746ECCED7206961E9928A10DB892DC59671
+ 9AABFC9B5B8392DF0CD2A76B58A408FF2FE710706A96E89F38475DD504DEB4F6
+ F8F22914C6A7B8446E238868950E457BEDEDE362D508E189123DF6CE06B10E79
+ 3981036F4C25377CB8422F5F562A266C36F1FF7C2A83875AFCA80DB84FDB75AD
+ 6CB4FBB115340DE0CBFB8BD2CAE2E0145FD0AF15EE4B5BE4EEFDF5EA54A530FB
+ 23A8EDE7E8B3FC87EC0744DB13ECC3C6C72DF093222B0A2663529B9FDCE5CAF4
+ 8D3CA53B20AF503B3141624D37497D2D1B951A5723B3AFEF1DBFA2E3D51CE089
+ EB4F0F900F6BDE529B30535A0425C24D8051AE5DF4C7DA3D835CA64B2F0C091D
+ 3DE80052998F9A72FEAB5D266FEC617FE4610A6814AC38D85BFE2F2F07393C47
+ 0A9F1307E68BB42FEBF539644437C999117CA4F34CCCC1DC27F5CC36E873BEE9
+ 591C38294865FCC2C99B560159A8C3FEA715CF9122D8C06D8725AB5E6BBC4502
+ 5B15DF5D3D5EF86E77036B435F0B40AD3E0090C76529B77B9C08870FF1BC306E
+ 8F452FA36D55B69B1188908D49C00DFCC133897566FBEC9C8AB64C221965815A
+ 814EE40EA254729DF39998E55C7045CF483CCA1B0A18203B0F759DBDDF3B06E3
+ 012F1D6B7127C0E7D1B06192679AB84F298733E11DF64ADCD59C8D23E5B4A369
+ 074CC2D39C85478099FFC2AFE112BB4EAAC67884A6CF5AF28A114456273AB557
+ 80AE608C4D5E2E234B174DF8D0D63AC774ECB395C3844D3E507BB443FB40C49E
+ 0A8DAA93A568E2A5B02AEE1BB1C525B7EC9AE43838B45EFB6F0A9D27728B117F
+ DFC1918C80E93EF1E3B82139CC02FAD20C088A45DAC89A6520DEDCEE5ADA2EE3
+ A67CCDED740F16F0BD593C998F2610821B6281492E2868A834352F3390948FAD
+ B19894DB79B24C85F4DC03B8EA3C21C90DC1DD5412573997719532B086D60364
+ C1BBCD154CB887FB8CEA7F2ADCED96033205717BC98A41A845D4593E469B9112
+ 574B718FF234A6D7F27AB6E04583A5AC8722FBBFAC683C13617837264714C420
+ 29DD3700FC0796975345D13B1944D61C7F0A13C92CF2D868A7EDC93E37DF5486
+ D74C36BF955F105CDCFBEB6BF2D814207A308D1A46E01916C859A1F8FF00FB2C
+ 9C3AA69126ABB16618B348AF6A07A5F7A9A5F01B32E19A31F3615FBE37B85AC4
+ BBE0D8EF7BAC72C68FE2D7A22DC73F81D1B482A065AF4486499E526478C3BC27
+ EFEA355DC48604D7E995928485FEEF674E28FBCAECA0E3CB60590F3BBF627C6C
+ D0C074711115648E243068B902A409D86F4A2F5721D670AE1ACEC1F10E496C05
+ BCD73D2832F66DA5EB2EBADBB16EE247217020221FB3C268CFEF2A6D333B94BF
+ 3DF710B51D20714EBB11219B3576236DAAC075F5C49CCC8534DFE96E44FD66B1
+ A662766C25021C5DEE46EA2A194938E82DC3F6FBA2928DF753BF9FCA99A8CF45
+ A94AA622BE200A9B0F06C7C939F5A40FCDBC8D7D37F2A3ADD054B01CAEA3AA84
+ 075EC03A4DD9BBE2A79D5A56DE5F3767BCDC1CFC1DF13A063B6E22330562E793
+ 926E250D2B7A61DC94198BE389F24A65A83DEC80A064E4582F548B8DB7AD80EF
+ FDAE49802796E9306E2ADE8B76BFBC53CA02F20F07EF4406BB633337B69175E3
+ 694532B0A3374F27689273322ED1C4D9FDEB2CD4E253C6FA97F71BEEE7F4519E
+ 1ACAABD5C5403AE4427864DE10E06680FF99CDE6BD3AC607CB03C9469D1114D7
+ 016BA12F525ACF2DAAE2E74A4460FF371F7C71701846EA0C907EBE938D9142BE
+ 351856BE83EFC2C5D0BFB25F9316CD1C3DE499D4C20ACF996275BDFF1BCA0CEF
+ 42AE136DB3E1C82AB88F308FF2EA0F00E8AFB8BAB77E85B4BBB302DD11F2476E
+ 29FE12863BCB1B6F9DDBBE973A7BB27A6E153E4342ED845262A662EBB07CF75D
+ F8737D00C1DB415452CB6AA37F12DDF9D7640743F2641A9A484362ADE24C7630
+ D15F7B82A5DEA9CF2054050D38BDB485A2B3A169E2881B7F65E4182C0F374817
+ AB4D31C88B07AA0641CF7B69CB31295CBB208910481C91D54D5154C4C2B7520B
+ 188CA5ACC176A006637B829D82D59CAD0D9BB17811B70F24E593A74C9334227B
+ 3B0807BFF76D3A992C76625F93DAFD421A5D36F4A9E0EA93208E4E1A5FC73DB5
+ 1519843DEA5CCF2AA04BC3D4519ED07235C1C6478B099D8848288336DDC2C0F6
+ 71E659EA519C086170D618A9CA6D24FFBD4BCA4E99DF86AF57D622CE6FC8C35A
+ 71C7E3EA43ABF8393B6250EEBF6212B5BF3E08DFBC8B984020F6DAA6E62369A3
+ B4FF2684F9564A65DBDCB688919AC3C285D0A7D796EC1DC56AAF7C75CF67B95A
+ 993F64E3D4A538EECE714DD5B7948413974B062BCDE2B2FB8C682C7A44516EBA
+ 917CBE51DB19364C7784208254CBF20016BA6F4C2E63B9014468FD387F672CBE
+ 9E1CB49465B46021169C7E513C02CCBD6B8C939A093ABDC3A819A95D6BBDA0C8
+ 28D20097A15FE58462254E47D1FE4D736FA77EE36EF5F2E7154047075E0403D7
+ D0C324254FE26BD7D808FAEBFB875D55D8CE1ADAA1D0E6956DE53D30C06B8B90
+ 50B4C3E9147AD723E9333A06E21385ED66A3DFB497FD36DA3AA3B74642E8D5D0
+ C50B42C5FA4DD53C8452B29921923E138309CD2E5AA9C87021F3BBA6F998EF8A
+ 1DFECDD8A6E59B237A40277DCB58C8447A2DF444786709B5F00BA929A6A6840D
+ 1EE6F6F487A928E731136EB9CEA061FFCCCCC8B549610EB5B3D2EFDC6CD90E88
+ 8824ECE1F445C15A2C1DAA39E691C7F99E71608C3A6946AD4501389B5EDD0F8E
+ AEAD70A468C8BFE40E62CFC160DB276943C6F3E08136BC711B8EF2DAE9139A8D
+ C8700054FAC4E067559C6F4FF1F2FE2785B0458E259BF99729B21C48FFE3F8A0
+ 1BBC3C113976327AA1D40DC665620427E167220284C3147B65EEBC9ED167CEEC
+ A813EFF24F8F5332DEAF0E0170ECDE2DDE7154EF4E48E1C5DE9C0990F23B2419
+ 11A1A716F92C574559976B790A3CAD328E1A433915E0CFC8586C94B47EB0664A
+ 37349CC8462AE9D75EECE95D7066D838A951C8A0E20920A4B53078849AF434F6
+ 2E06FD8AA01BCF9C119001B3F46AA73657D08E388CD06B2F1ACF8E88F7FE4C8E
+ A814BE55C41C1C8FD3D48BD6107C171741ABEDB88B1E1BC5CD4CEFE317C13729
+ 35802C886A31C193D11DA0DC3815D06872E5FF0A6898CC60574DE2920AD80864
+ 4776438717670431178BC7E08403022CE11ACEDCEA5653F48E2FC86E730443FC
+ FBB468CAA5CAF32DADBC8D19B6B11DF9C40B38630EF18035A141FB432EA20FD7
+ F9E4F61127423E976B1AC8E27E323A3C4D11B3258602E6E9E821C0EB88AD36A4
+ 86DD5C2F9A5C1ACEE02EA86A5B5943F0D999C56AE54D041AB7A3F91E0262596B
+ CA6568BE184C38F1B144A7524897D118DD0CF247D2E62F7D7D8BF87A9FF1404D
+ F2A5AC21B9F5B76E1BC19766674E313F6259C6BFF12CF4B9CA67E38D77979B89
+ 2151D79A2D55458735CF2200E0A6055457D7E011A355D4CC0C3AF7DE6A1CE337
+ 85CE03F8E9A3BC99B59C7CAB90C9FAF853F8EF18230B16BE30C2184C36DDBF0B
+ EDB68CD06C1368FE63D0B18A4A64185FF9F7D68668B597EB6BF62043125CEE7F
+ 8015DDB933C838D28DC6CB84032753C1EA6A26975560438222270E8EA890009C
+ 31FB289F18F96EC381ED0D224D511C15704C83ECF6883DB2A84D16D42BD98911
+ 7D3694431402006C8D4063D562185BAAA399AB0F7178BDF88653695DE9068676
+ 4C3EED8B9B1B5FA7C898E8688337C01B9E101B10CC0879430F7F49530A8CB3DB
+ 1A038A259B1947B4107BD35C4270D5F8A4F1863D00183D82AE78831A6922FD52
+ C12004A72DBF0EC6FB493CA5BDD939DE7C2620335006D44D45963AF5122AB255
+ 45F2D1B1AAB5EDE8F25A629FA7F31E9212E1594D82F19D2DDD3AE062C0EB33A1
+ 0899FADEED59F623025EE344D4B07765919015690D8F23D60E6F2343BC8639B5
+ 759CD98B4147A7A9CFC0752B738FAE7D4EDBB214FE82B485936E07F2CC9A90E9
+ FD5C6A457A46856CDA77832064E8A3D9221A175A7C2AF71FEC4DB2E4D820053C
+ C18AFDE5CA096769C0FB83D13E39503854C64E83405C63550C5B83E90E0DF3A6
+ 328B13E2EB29C82AA6D8D852B01FF6F47357B909CF2AC30D1D312734BD220D56
+ F55E4547A1D70825AAA737086C51F088E11B4216E2FE26E7D5C9AC9F5A315554
+ 6DABBFEFBF402EA810C0191B3671EA27ED2454284B253372B3786C5D976A3264
+ EBE9A814E2AB97F4E818236D07F253A14F46B03A6C7FFAEFD120B56F7A9607A7
+ B578B9D49E574D2AD02FBB36EA5D0EE0DE931D095D037DCFDCD2A73CE86661A2
+ FEF602EEDD487F8AF71859F8F37F8BBC4EA1B76D70461E219055E0B0B72F129B
+ 3B2C86F2EE502F2EF2A90C3A1EF0720DE41F5906708D9838FB9EB830CE27E20D
+ 25B50A0ED1D904C7F9103E6676B2D7E6B327C5B9C4685ACF7EB3106927A97A50
+ 9F664B3B1C58925AC03D01D6B187CE3E9816299E3EFE330437A88A9C58C7DCE7
+ 787A986C1EEA86156FCBEB3D3A2F3F1AC8381BD921BC973823D175C1B0DAB71F
+ BF2AF97BA4EE89B63614D7822D6F95E37DAB190CE3DB6BF8A865FEC0C95CB00B
+ 401DED3C7F18B72707DF69190DFE03F1B5AF071B00871CE779888984D3C0D8FF
+ A9890EAEC7BC7CE90A07BFFCCFC94F8660570C5C1932F176B35F2A4698DE9A4C
+ 7C1469D025056850AFA9C685DC1EF39179D4C060FF71192ADF35560B2408F453
+ 7FC1CC1A9130A89B0188D8C1DADFA6D491A1FA019D2A8C20BC6BAEF5A7AC2683
+ 4B6D84567E0AC8E99FA32E0E74A3C680E0C0E65AADE0BF8BCC44C1B5F477F5A9
+ 4D9A702A4B337AD188A6B48EF95020C1D3197C866B23C364F028F257F73A83D0
+ 3DED84D3EDE70C6B5197B0AE69750818812912AF1911108FF5F1C0664F230A11
+ FC6735DE3CB3262CD9DF62D4DF6DFB50AB1D996DC429CBE2DE52C5FB789D4908
+ A86814CB816D653C142B977C19099EB38E8B44129FF768FD2176C26AECCD6130
+ 5DEE9938B178E9EA85F8974224CB47B8E694379748A63D4C73003B2B3B987998
+ F11BAAEB4ADA13B5C617EE269C2A6B154E9DE89A8F188C16311417507656E5E4
+ D46C8F6E3CED557C8F999CE3FFF5BBD206B19E2E3DC13AAC846291BBA5FC9336
+ 542AB1B3CEF2C17BC27A60B77E61DD614D880D2F18E3D73620E6911C9E60681A
+ ADAE60DAA24A286F1D31004EBF4C92E7EFD950149830B65B3642D87800AEBFDC
+ 5560609739B9C0EF017BC8F1CE611A468105F227FB23AF8C66FB0BB73D1926CE
+ C91F048D39A4977AF2B2F0651F7676B2CCC8CAEE08D772FB2C129BCEBEF40AFA
+ A15ACAB83354FAB5BFA8E9460204C9CDF5CE28134B2EDB87D4D28646881A1A83
+ E3626A7C15723EC3388CDDA9F904F680229A6DFBB98E60E8C0203FCA0FFEA6C5
+ 572D0460F0A7BEE5B9F808463FD7B53E67C1039196D3ACF887E92205FF3388A0
+ 46EE828D5886A342CE515044E5954036684CBBC2749EE76F48C7D7ED49832762
+ A5631966C5B3833120795F6DB54B494698F5498600946E6594CFAE231FF00269
+ 4FFB36A057EE5862E3514462E710ACC81E851E11B437A4B088CFF726119ED3C5
+ BBE6E6095A1CBE123373BA609CB32AC1099C5A11A04A9B8128BA87C73C9790D3
+ D1091FCAC9E75E5C3455F095F614F659B7D4230DC27D411E6444FC2912A2591A
+ CC4D1BBA67E1B8BE08AE41BE05368212B77B8D9F5143C54CDE0578922503DBA4
+ B3123A4C662A0672B3FA768B34D6410B1DFAE923ACAE13381D6D2461E1E8FB6B
+ BF720C42DD1B15008451D697DAFC3A06D29F2388FD9C50A1BC2C5DCCF493B36B
+ F979D42DC44FB91C9FA399696E931A649456EC9E5E883ED292F0A73AC26D9AA0
+ BBCB6447FBFBFD29CE092AE27E783C069A564531EC3BD871205F751EF862BAA1
+ F05D965C928DE9385690E74F9D64AEF8657C941C595CC103BBD4C0427CB8E4D5
+ 1F89613DA5E39C9DD65CDC245F116A27313AE27CC28F689E1EA83B0B0D1BD7BB
+ 2CDC82F9BCA277E8E88E9966781B69F407CE51667E050E1174C24B0EEC23FA23
+ 64911CD93DACA1104AF0C204BA24A12D0BC0A2F9CF407F8DCF9ACB7B97808BCB
+ 57C590DE4437E585EA1C4AEF506B53876C66DBED4052CA4FC34F1276488EFF4A
+ 5C0BA4288B486118A12BE2B336504A7CA3BF9EF00D8BB311C14669D63916FAF8
+ 640E16246B00FB874B173388B4F35D4024037249FA43EA127D6FB1289FDB1DC4
+ 35EB991A947CC04A8184302C9D26BDAD8338286B9E6C25F8FB28E56FD2FF9264
+ 3B603BF70808A33D32EAAF6BD9B7D3D1BB0DF4ED309C4EDC0680E20E2EB257A1
+ C38BE5B8A403776065099EEA90657409F81EE4BC6C8E62D158CD0D410A8E79DF
+ 1526F4838FCA8C3BE0536C0D534FE61195F683BC8CA14856E4F5F576C9AE9943
+ CE59F445F5206178F510B07C88051794063B7D0CE621D8991112597556CF0B10
+ CC5DA7615B16D794E01897FB2C29231F9F1ED14BF36FF3B800DDA7F04D3846F6
+ C2012A10E5408051333766C19FE9E17CF49463CD8490C098CAFD5C64F31B4B5C
+ 33907857DD955C999B01F63D41E0025C1CA3DBA71057304D5F00F13E339AE81F
+ A85270EECC1F56BA09C3F06F0E4FFE8E04EBBE843635824EAA8A234F179235AC
+ 4A0BC0FED9734E1859B2B7A0D649D0D1EDA1042407DEB68B5533234966981C6B
+ 21BB4E48BBAFD8F1DED2CBDAF6F88F8BD1A12D7F0F726A494737E8B45CC730A8
+ 348F89AC5B2AD0BE60BE023CF03634E7E62E2C2C770CC93191D46C73BE8EF844
+ 112966C27D0C7B7553E94F287D68A78A086B33F9017DB7C52209D1AE28CC7652
+ 261C8A766BC883A10E6AA03993C4B0024080F996F1363CF0FC62EB2727C43D29
+ 96DD1EBD9668958100BD3E04151A5F19A53E929FC412EF096A1BB3045121F2FD
+ 6E5BB3B09F9577C73E6CB45F6CB010829E0EFB6313D45DDCD435169C5BDD39DD
+ 828771825856DECA8EFBAC2594AF32F5EA75A9A3AD6E7D763E04E848AFB872AA
+ 93429CFC187C38A37F8753B185FB17110170F1D3CE1C7E44AF25ADDBDE6F5930
+ 5B0BEB1ACF9DA566D814FBE9D73683AA9BC3EF00C11EF2D13FEAD7A3B6654961
+ AD644444C87B0853D2FC652707364011AAA132A1AEAA1C0CDA1B49DA906647C9
+ 9D70D62906E4AEA736E1373878D5EE08245B2191731B1782B091661518EE16B0
+ 9342908BEF11A7B47AA3818329E3CCB69C8AB144B9384DD7A3CFED5C965DE374
+ C663F2B5A089BCB4AB22CCAABBB4025EE4DBF759476731ADA93D12A79105E525
+ 3C7ECCAC78BB75154A1A92E1026CDCBA7D8E5ECA65E872892A31EB1ABA8B5490
+ 0E29D0A91363CEB36C4743BD844CDAAFA6E144E930BB522D4453426C37426621
+ 134808F3FFFDF13C10EB662105C84C7CB8D1F6CA2262C77A67AA934B347330F0
+ 607AE1FDB1560F21A1F090AE6FFA89BDF5CEB040FBA884075BD99A2AA71FC265
+ 37613DEED860E848057891F1EC05B2ADB568DFECA5F19D3AEF3AA7A4745F9CC0
+ 3BCC06BD824CCAE18FE47885D2EF8A8B64CF97F6E9221B2D7CC19248F32691F7
+ CF9E59E7116B9606A59DE15228614AF32239A036269B16D2D935976D5B5F1E79
+ 8E4C02386340D38B8C090C45443DC61A4F1EA5E44C9998899EF8D1D72CD34589
+ 9E0B6A9EEDB414FDBA5C7FB4DD5339F009090BDC89934A0F8B3BA270E9CFE028
+ 259FCF18EF86E9F1C4DAC99FAE9ED0A9A237F37DC55206A817B099F5721963CA
+ 579782AE69D8673679D4FE0969CEE5872C785AEF727B13D640F6ABB8FB276A41
+ 858C41815FFEA92E754C356D1CE5EDD3CC801A48EC6B881DA0C4C283237DB7D5
+ EA5203088860EC808A5A3ADA0A00FBC7675DED35BEDA1B1F0960EA4A5A31533E
+ F6575BF137BBF2A60D08BCAEFEAB594BFA8E16EAE5A1FA8DA1223DBF94C6ADBB
+ 695921AE4F77D44B951266AC4BB2261630C329AE85FCCE1F8E8E8054BB3A6775
+ E966E3A84C273CFAE9B993685B86AB99410D32EFFD7A20740CFFC0C220756826
+ 85888A16950565FED78B87CFDF2300F3E2CE54BAD21DE21B7D57A6F602C0E839
+ 3EABCD9A84FB44742B4D3AFDADD3A5CEE7686512B8CBCE3594B407A0668DF49C
+ 03D7523571CAAFA58DD723F1819DDE6AE9369FAE5DBCB942069077C5B98449EB
+ 14C5EE522CA07B3649532DD16785ED59C2828C7E9827EBC1468EF69541279AB1
+ AEC93BDAE45264FC8947BB288F3604A2497B0C124147C6CDFEAD96749061C0F5
+ 7341676D323E95C83B63FC4DC5E1B311DAFFD3D37946C2C0E374850D2E1B02BA
+ 563B3D928C517813A2C62137674C888C2AE3C8D6A3DB07BB42084BD493ED821D
+ C732779749B1AC7921F08597BDA062EA6D1A0E9FFD1836E3C0B8B81497F79ADD
+ 4D2BC353B740A4FE35864B31EFF78D5A60A4C9BA3AAA8335E2350C1491287ED9
+ 0BF2394FF053A564472D12ECCCF823037E46B17A5583D882F3B0EED311337650
+ ACEBA8EBA5D42D041F35B3E1E84038C6957911A0925AF75800E4577711183B33
+ 7C9C8C26CE5DC05E0F2BE585A0B1423503265F3DFB1D1E4A34999AC683A04B6F
+ 76173ACF52E0B6AEF3C489A4BE750C59399707A25A510043CDBB95F3CD74FF12
+ 3152F1516AE3FD8744A4F2D85894CF4AE7DB3E00C10FAF6D14DD6B63C1445C93
+ 74565976746165076FBDD8D1C776997F874B0DF13B8EF4CFC8D78A5E5C7D07DC
+ 288548EFE6A1350A860877CF807248EB5BDF6193F0C56376C3BCE9D016FC6E15
+ C89E4700FA9657BFDA49ADFBD1A342A158404C64197FFAC3BCA22A878BFD58DD
+ E3F8174C12B26CC691B1902E3698728238A64EF532210D07F86315DE3AE7B5BD
+ D8EE66E1D018689BF1728BE839FF99E9B036F15E4E9194393FD51E44959A92B9
+ 4ACDA4B62BC89327034B9F56185E31571EB5E9C6BE0DACBE3FDB4E9AC75AC8AA
+ CC9273AE4EC698DFCC3B94A4F731942F7E699AC8A258C2C0E78D49651A4B5716
+ 9253F747342D6D743571544D8DFD8F5BC68E89596BF922DE207BEB62EE8A24A4
+ 1AA696E3FE720252186F859170BD91522CA17B474CE826004CA02CE505E87A7B
+ 94D80C3B47EFC4D0B96C49DDAB8EBCC153CDF9C63AD609CC25C26B6B21E01EB6
+ A8CD4A7D6F4D21C33C5381E36871CE61D3E0B8A97B11D70342E9B66FBD93F3DF
+ 071015AD30376504D8058683757368625D975AF2F010A0E98A2B14801A51D467
+ 67D291D8355099056DA0B7124C46E6E27D4A9D9111425BE63F4F04250450B710
+ 7AA0A9A6E2E114C12450886E568579F479BDE4F5E1E5B2A95238BB60081B7FA6
+ 0C90226B18B510050159EDF7A15A5A97BCAEAE6053FB52C2FA918181965F213F
+ 30F3F8D208BBA786BFF8602A8F00B6588ABEFE3DA149FCDECE87A2944B211193
+ 3779D87903B1FBBD01A4CD05B90B24CC9956452EC7B5696EA11FCA946C6E22F7
+ F62E56702DAAC6627DF70926A8B31905172F9AAEC20D4932D730256DEB6A3B16
+ 12196D7F08EBCB845D0D756A9690DC0EFB00F2CB416AFEC3C250FCD2D7D6D243
+ EED82B72DDF426EB69CC170BC7263712AB867D57351D7D1397C389C23C034681
+ FE82AA5F482C7940F255099239BB4E188F1ADA86E6C3A8E3C6D273751518BDC3
+ 8ECADD6ECA58BA6FCA22DFAAC1CAE06C65C2C961334986A0E564118796E51CD7
+ 9A021BC80007780B683C2DCDDA394F57C2E8ED48847516F8A820B70ED6122FF6
+ 2D98A3E2DDD7B48506ABD4376A7C54DFC0A00A248F24010ED8F4329F13BF8C43
+ 6B717264C5416B6319F477AC3B7A8088949CF72133B3C3A94EBF17BD9D518351
+ FE6759132CA177BFC8156DAE05BAEAA2AD18FB08EE9A8EEB4CA5869AAA1F7EA0
+ D2511AD8F11C0E22571507E326C35F74B5F2A009B780D3B443C17F0112D6B772
+ 3B340E4F607FD9759598F68DC735F93354D86B07E23D191AAC5C4BF219F52A67
+ 9873CF5512C324061DBF603850649E44EA68F1577678E50A3B720912E6B0B9FD
+ 860B3B51EA94E1FCE02E2A98FF143C01E0F5372D32B14927D0324CA7328D4393
+ 00A2C7F3A3B098572ABD1410AB5B0960F64A46133259F80314A6679EB02A841C
+ 238A5613EB1861D5CC646A6CF1B4D373846DB693B52B936D75786D57A9ED5198
+ 0A05C41AAABDE4099A8F0776B2B88CB2D7434F47FCD538342D76E55679967491
+ 440A6950309C5AAF7F7D46D2933F4EF2416910CF5407607ADCC32FB5CA572172
+ CFE1E0E5CDE9682563C17BFDDAA28639FCACD5F6487FF55011DDA0A42B19DF36
+ 49A23CCE0DFF04C9FA028E2758A3A37DBCC567AAAEB0BD4CF6B68EFB0EA463D8
+ 41659DE3EA58179B41DC43F9C41DAD411B70B7885AA592DCD5C3277DFDB4A58E
+ FA47DEDD677BF1035E98F721A88998E41EC3ECA422556EC72D93EE1191B2E170
+ 195C81127837F7ED06E90DC9704E3A337B697087C46578C1C64F2DBEDE29B808
+ 6ADB5BAA7728844297AADD1E6D5294CE903093BA3F52B2DA329419B300366C44
+ 44CCA7F6A1D070BA3F84833815A177CFA10038E3BBA3F8F2091B9A384202C61A
+ 5DF5255BCDF89996E294B369484DFEDF58060574F43C43D3A917197D067D7900
+ 8A0F31B20558D626CE2D9C78D07D56E731AC062E43011DA5B6D643B168B31209
+ 75008552AA89E61A859ABD7E5D09FBB691968F899B175AF8F80B7C5A73F2E5D8
+ 5FE5417D20876C474D9711C7365ADF8D294C940513C386C67BD3D364ABB5CE1D
+ A096D2A0813212363155D08DE7433D9D287E2F100CDAF0466E5376E93F4D55B3
+ 5D7C9807AA0CDF27EA973E6B9CDD423FC078FF566EC4E2C1F906C48F46D35809
+ 6E139CB9545B4AB9C8F9E7566D2F4D55B5BA5CF65D1909D0E5133B7EE1489FC7
+ F1290E9959A91E85A1EB2A2E7966FDB2BBE2536F7D429ED9E64FC5415F458353
+ 29E0D01E4D58A55846FBE4FEA1CC70DCB32C4D57B9390E4C7E1F7DB27C41BDDD
+ CB6FA105E57A8DEF347DB44CAFBDC23FD5735E34A681E7153E769C20310405B6
+ 7DA5C42145ADE57A8AD81BF14BA766DB5884986230F19E3CE52EAF1AFE281A40
+ D75CF07180CDD1EDB28192CFF94EC12B897206A4FD077DA5CC894B7C9E0D20AE
+ CB44CA027DF70BED52AE8AFDBA2BDAB12FA081C0A26490ED2DA4EF01B123E00E
+ 358B46B93E69403E8DF2F0C5EFEBA6E2057027AC159B95BEE2C23BA75C6ABCA8
+ 7F71E1B4AD0E4661D47CD4D25093220861B3F8D8FA67E1E778B589C85551D6D3
+ D3FFF6095AA8A61B3C282103E83BD33711B2FB8E3730180DC2B7DF4432DE1D14
+ 97CA9B4F1C03BFA458256BF10D97A9E439923A1C83CCFF6300EAB6B4AE6E0F7F
+ F1980BCA79C29322276677226EE8F0CBFFB6CD366241D67DC86075E5CEEEE14D
+ A962E00A62A4E317ED11740292557611D34A40198E2F9429903F4D8F06B5654C
+ C091CEC7C7065FC5DCB175C81A365C53F361DDF184202BC1C5C4A8F90B6A5B73
+ 0B04D6695A3385ECC5436C9AADA5D9193B6AE5C4BF5D2CF42475F6C49EE9DF44
+ 506BB18830F7BFD628FF3D9A9E35DB9098C7571DA6843FAE11B862B3A483AD60
+ F528865DD123916FD31A343A00FA9ABCBB7B19E537097AA25300FD59F5771387
+ 5B329E0CD3A4A3B192B310285611306438A74570565BD450AA0AD68E5634BEB2
+ EB9D7D28E272810F2F4BE6E109E42F8A2E94AC09ADF852B70623FBE7696A73FB
+ 7354E12BFB75345080302F54394471E7F3422440CAC1069725E386B03912F452
+ F9F34083FC93A856EE1E19BAFDC86385D2232BEE1FB17240421A2FBD3FEAA2FF
+ E1179E443C18D2C26DB04B6B4AF1D2DBA0744B87342D46A91AF4B2523571DB9E
+ D9930E36CD044F9F9CD79AF60339DE5A2470E31E251353329E8F80A7A5C8A673
+ E0F27D06A7BFA5EED1BDC63C3B9E080E367D838D662DE6449BBC77B2DE01E988
+ 224830B0E59CA61AE85AE56B1088B4FE58CA0461A03EE3B99A9AA2230E00E9B3
+ C57B882DD818DAB9952A254DFB94A25A0F57B83B246FB0432CD9402424BC21F4
+ F318029AC9AD11E3D43F0CBB94F098DC86487D972B745689481987E6F72E13BA
+ 1F6151BFC34056A0FBD53C2FB5E08CCBCF4D27A38D5D2A83232CC5A00A0956E3
+ 16C428D519CC56172C535EF886366D21242E245F50E1722C6C2655FA06054BF7
+ F7C9D5E6A320B7E788CD9A2D10A5BBBBCC09750B001F72115E049BB3EE7E1819
+ C9DBE27AAE836F767825F98110C62DD379E104BCABD0F3A4FF007C3DEE70DCEC
+ C6B095D647116AFA76A09363EB2B85D5D732C39854E9665E4FB972C16D0A2C4F
+ CFB34A420F27CBB0C0CFAC1F7F6244ED6F3EABA34C33EAAA3160A5ABB8053183
+ 92F78FEBE39D30316E3979E7E10D26A3E93801037F8D603668A442750E2D5EFF
+ AC8FD38BC6D89CECC7D1864A25C0EAE4967B08AC9D71B6F43AB53C8D65381316
+ D36AF48CD8C3E7930DD405E8399A44512261A5251F2486220EC74AB6C0FF0B35
+ 1AD34CC1EA0B600E8CAAB649F0C96E77D4B5D87201364C5C109A8938BC1622E0
+ 474981EB1A237B0B40E9B313FC1835AC9F9FCB5DA9B6C5DD0B1952040A234269
+ A231DFA4FAAB8F4CE8E8F7BA3F9414CF5D1E5C3DA99A7872D27AFD7C4DD9B2C1
+ 8B1867D71A443E7F51FBE9FB4943979557E6D68762FE2A8E78A203EA459A5947
+ 25A83CD862F669BED5BB5D16DB595E7B350E8B703A07E173EFC8559960770D26
+ EFF86CCF70ADE6CF473262810716192CFE0E83DDA99885D7AF58927526D2D7C4
+ 6380CDEF7D03E8D3C0256039CFFFAAED22147267EE34783D05EA0039A83C2DE7
+ 61CF7FD9D140C15E4AD6491B8AAF5F75930001CC937844E3B98029CA5F2AC9C9
+ C3CA1ED2E150F7D8D4B1369C9941B3712B60409611A7E35CB8931722808C4FB4
+ 917ACA4D8BE987D2DBEFC6FF2C20707B8C368334E417F4BF89C13752D6A9B69D
+ 9D6F97FDE577FE6C5CD5B55134F665B893147D71A77F3C80D7775EC4EE4FF756
+ CD47F496094788852AAD87D92CEA7D4BBC739695F52D861CDA2457B6995E8911
+ D0F83EC71C10264175A3858FFB21BBF2C6DC8F3AA5284E9EFB937B95D6C46F12
+ C7CEF5AAB13EEA15CF04EA0F79EEF461E7A8554BDB03E3B00D108AC63DA1209F
+ 266D27BAD8BE2089F021341EC8A0BEE7F415F84ABBC71F069D281165D2B21644
+ 5792A12209382B107F7F6933ED6131D16E6D43DFE8EE72AC73758A825C0E0D90
+ D7E859300ECFCDC11C2DE9717C1F4648292D95D8E7A55956D3241F80F6038439
+ CC4E3E4E6810DECDA6A6F27B6833E8279D2DB8652C23606A4A15C8CC46A4CB71
+ 395AAF7B20964319922EA17DEBBA940533E2CCA7C0A49EAE6A63007448970709
+ AF334BBCA2E931895B615CA1D7BB24083DB0D6D2CAC598495DDA4C552D711C87
+ 171DA9CA312E0D35DE880C32ACE5F0468FBCC6FF161CA77EEBD65BBA57144E90
+ 45056207502647919A25A923E0C4CD10BB11C2F7FC687605CE82646C48F615CB
+ 07DAF23D122989E672880662D9558C0C7F893FA0997974343D82D864102B791D
+ 84596C6375A99FADD379A8624888C0CF63D641CD11F4D3C7D44C84A200A49FE9
+ 5BF9AC0709E87778BE8BA27CC2CEFC7152A3CF8868FAF863EC5938E0FB3BBB4B
+ A5F80CBE4BC3B0F5C962F6806056AE6A815B776F568753CFE12D6A642C02F4AC
+ 7B65743C7477650711A91C178635614C8BF6AD5A16C83434A93AB63970B59843
+ E79B5BDBD0F9EBA994A819E17C67087341E74AE0A068014B4421880E461FDE66
+ 2893BB531552231C6A05850D8F91EC091702D01866E79FD4376FF6DF0B0528E1
+ B279C35E151347BD33F59D97B950EFD7C0032543A82EE9DFBE64B033A013D1C8
+ 095337AF16ECA873515B6D7FC99982E52C34D7C481CBF74B0B391EBD1F7351F4
+ BB56EF3D83FB29571C75A74B50DC2D1F4C933851CD671E2F00A960E8E6AC0140
+ 7AC83B5D44329DE12E035128770B66D606D9939AD3C9BFEF97A69AE7CF886C3D
+ F622615930BF71D5DEB58F2C6F2D4DE5B3044559B93EC6A1A728D6594FB61C78
+ F522782598F7190FCBA25329AB421344D5835C81F2D2969631A00ED6B2979C36
+ DC6A867305BF03B11F79A8A3DE07A73B3DB4C242A96C6938483ACA52034EE7BE
+ 15A606949252A3A41C0AB15E07720191E22619E35016F4C904EA50C2D7C00B62
+ F146A4EFF3DF6CD170CCC67172515FD5BDE06E2EC85603CD9596AF014AAD4262
+ 9BC27FD473FCC825960DBC8C3263B5B946D33DBC7F3A6338CC3AC14DC8A57812
+ 124FF632687FD4FDE092D73FEE698DB83B11B64C21388645B68DBA9B93FA259E
+ F34F334C02B94A3588693BC5A3F31452716E94A677073066B14D30647C2EE18D
+ 3F8B91753992A0A50176C89EA3CFD56E34AD1C29D02A5B928D82F65127B7BA4C
+ 74D8BEFEFAE63D5082D8E7FAF9AD1B0D4C2E2F5AB1EF76F9DFA498D224AE558E
+ 54B0C1BBFFEB3AEAFCC869364F02050D8FE0A55C835DBFDC2087FB08168356DE
+ 59EFAD389A461698EB6F1AF71F001EF7D8AB508925714441D79A128B06D86571
+ D13C5BD07213AC196F7D7A1012B8E99C13EB36E49931E381C941FD14D50D2911
+ 9CDAF5C53B5A3E7E40D3514EE52B56F2ABFFC19522E5980FED9DF489E236D06F
+ 3A1DAA4D52FA611704F96E1F5CFC99BB070BB65E7CF42D789F951733787B259F
+ F55003EF44AC0837F7D5F3BF7B3297A5AE289FAED4EFD5AEF271CA1D28EF04CC
+ B58E502C1B800361A0FF29A4383028CB8485D54A4EEAD31B9FCCDA9038CAFB2D
+ B923AAD5BEF5C268231A55AE5B83A6FEDCD08BFC31F788838CE62BF3206F8DE9
+ A3D6C8CD524BDE46B2B767993C1724B6923FA50263BE89789884D5B773D0EB72
+ 4018BE4335DADEA420C8E1761982F07C6ABAE8C539A74B6778A4610556D8BF88
+ 17F78155823A82A468846045CC9B73157B0A69419DEC8633B765367E8FB3E677
+ AB231C36FA41A37272FC25BCAD708A1599C8CD70543EE93579ED5E4446D57B17
+ BC8ADD5757255D0EA4B40AC6A47A3C6327A117C0E39C72181169F6DC86CCB8B2
+ D29081F20DF356377A4FBB5EC0F39ED1AEEB1E9709A9775D9505C2F65608D212
+ 981EE8554D1A411329BFD9E5F028EAA8B8A00566B2BD7BB9662A811021773F3B
+ 4432E41039D12B5D69BE2E87140735B4056B60ABBB23316650B5689C3A53DFD5
+ E19A18D67BD10ECB42C25C9D24B5245E4EE0E6A77D8DAC09CAE0E29B98341898
+ F09207E0EA8B5A586801614F9315CE073B2D438ED69B129A4FDAFC48A1506842
+ A140B0DEDBB3B983D1587990EBA40D0684B817EA197832EE2125077FA7FFBF95
+ 5ED96B74665D934CB15330EA1A5ECA3F638CC666CE0C8DB3FBC8270FA00E2A81
+ B2B5BCBAE9B471DECD15437A430F9EA9E5D33D6949AC8B771CEFBEFB686744F9
+ 92FA162C6BEE59178220ED260E44E0B1A4F86F39C3BB020DE3F8E8974EECF9C0
+ 747FE6569B665051AD4108025A0677F4619ABF2F007EB6C3A07F63B9E90B9A72
+ 41DFD0D6409D0D52F902E34B136AF5820D57A490EEF516B118C51E04DFB7DB48
+ E3E8FA4812EE485A2A55B94D29517A01AE263E4EF448C92269AD9B2731F88799
+ E7644F60B29C0BDC644D485530D9C3746E5696947207D4A229D1E24301FE761A
+ 7A8109E2F33D1420FB600B68C068EC4E2A10D0D5A7E5713730BF6C555E400E31
+ C25CC6DD6C5A320F76A1445D60E680F22661B5A0D401F0362B3B6C1E71596994
+ 2D902A70B8DBB267203F5D61473B5821A56735C95E49822F8D67E3D57848513F
+ 5D223DCDD56CB139286D35FA7667952FB2ABCB445F8C8619576AA1403141FBEA
+ 36E1C2093A2CFE43C689533C4B474D75EF5689889E7265FE2100C3CE641F884A
+ 11A741540582C46D88291E12E99F8FCFE55A9B755DE5FB46EC20FBF8126A2042
+ CB9005558719C69E3B86CD8A0D97A588E03101A58D939C7E1283812AEA57A2B0
+ E3C6F11C371D13CF0F2371ECC111F2A785B9AC024CB7FF0C46055687044FE2BF
+ 20FEF93A5DC42843975DD1CDB2C22DAD2300ECCE7EDEF836139BD2EE072D5E9C
+ 661E753B58FC4E200FD24645B893D2E7EFB74B03EDA4EA26FADD7782D8CE15C3
+ 05A9CE481EDB233CA55181034517F3CCD5A647A4F7A20E108D7AB42EF1E897C1
+ 4BD114ED8B5ED420BCD211652CD1E839E12C5E364895E125747D82F56447D2A6
+ CEA81CC1E60F60BCF605DBF602CC5854A350A341457FD0BCC1A91A035DBEC0EF
+ F9D4601A97CE9346D542C70DDD90A46D816E48DC5F9AC59AF3012D80FF89591F
+ B36D2185D5D02713FCA171425A199B4C8F01305A33F5A917B11E070AD940E45E
+ 1F5A6876772EE6F0BE2C35DEB09F3769B9A4D98145BD702D3A9690C9DBC25C96
+ FDB912F9D8FE79E2264079048FA7CB84368A2AF64FADA99B6F8F6BEBF9A0F0D4
+ 547FEDD616F1B69F3621DB0DC5D5FF62BDBEC1843A01B735C131303EC530DF35
+ 68CDE5CA43697C4E1268EFDABA63F196864B225E525425834C689235432B0B7B
+ 8E567F9D756E546660B0DC23E1808AA9EB12A87269AA6411BE5051A8D95C5DA4
+ 8B199715AB1DBAF0EE0583D6552203015A0887FB401E264B0131FA7522657C6F
+ D777B73108E0380C9D306DA470A8DD05176B05B8DBD5A49EA7B8457DDE003D21
+ 6780F28D1F85074CF4B7DADDD10471A7B03AB60A43E1011992B5E25E8034D09F
+ AEF9B73E3A01724EC3176B3F28EDB15D0B2003880B10683967925E3DEB40206D
+ D1A94A60331CFF31A040F7D4BE3400BDDFE49D146139CD36A85C4C90F9B3AFF9
+ AD627EC33D83C46F81E4696659B7179A2D44F3D2591830517DDB5FE76DA0A7D2
+ 72B62A8ABFBDB4B19A6C8D9F2D0B2BEE977C80BCCFC677F2C593D73C24CE651C
+ 6B440DD98BACD38AD5663518A81D03E1153810781D8A9E080EC197855464054A
+ A8EB4F78DD159EBEDAC86271B7710B7D58CA8E51D03DB2985A0C71559CC2FD3F
+ 8C3E9DAEA19137ED81041523A14B36BBB9867C2A6EB3B3EEDD82DA194A8A553C
+ 35AA0F3D074026534D602B55CC88C7C4794F1C7287F275FBCAA621A9795906F6
+ F15E093F6164AB4839F9C1679691D12F15DB2E6E8FF8124EFF5B2F4CE8C08844
+ 05F6F064232D70332CD35E7455E5F079AAEADC88A4B776840596F3BE64C735E1
+ 71F63833E5DD887A0A571CD74054634B26A97C1ECAA4AEF6E02B38045D5A7ADC
+ 03BCF9CD2A33FDE2440A9C4CEA18258ECEF0EEA354C44AC78F6FE064F61500CC
+ D9538A3E42B93E3A1EC394E3F365416AA92E9C20094FFA1968F491133C4F01D0
+ 9B714789BDF9203DDBF4223342122289C96CFAB01C10D0C0C631F322F43A351B
+ 0C473615ABDA1B375DF58EEE257A0F95CBB8E8252EC99F6C2A6C491C9E19A327
+ 1FE75DEEE18DE5C73B5AF61A8A97A7C88DE78290E448CCD749FC24AF1ADDB0BC
+ 1E631A5ACE6FE7B7261E7AD7479F975A1DDBD2B051B8F159A3806187C76831CE
+ D01524FD1D3E879E4B0E28FBA965B9ABD63CABEB5BED134D994CD15CE0378752
+ 5F9275ABE95C9BC8531B737FEB86850F72845EA2963460D203907F5DFC44B217
+ 0E485B4EF415C7C954132717485735563D65AF28B944839EF73AF8C5B78EEA31
+ ED16E9FBE0EADF33867137A81F76D9A632CED0D8C96FE2BB9801E601514F3615
+ 6C4105C7AF9C9EC94AC027FD8BADD81D7A0AACDBAE8864F784A9292BEC723888
+ DBDC17EFE1BD3D235FE1BA85522B23D9719700B062920C6E972D14DBB959095B
+ 6AEC58F43FBAD49A87EB04BF63BF95149B2E2CC89DB933D577337A3AD37740A0
+ 965FE340397DCD1B78401E8EE27E013A48A47BA0EF9EF2C1BD47F1675CF0C5AB
+ 9FEAFCDCF4A94EB1FE1D0671D2C00DDC9ECCFC2B60AAEABB04C8664BEEB6B44D
+ 6D84F999BFD915F6ECD0159839FA5A70753A860820A2546661A032F30BD2803A
+ F2326F7B9CC718AE23C30925C27C097B5B3DA26843942861075CCBBFA25CA118
+ 0D3447473C0D53D1988B39CA4210B6BF1095DD226B21A692E27C7A59D118B0FA
+ 51C5169C154F467043EEB378072F3137D8887D01895897974AB31167473DA1FD
+ BB0C485E130B4F900F5518BF0CDA5ACCE1E5A02B25B3CB47538CEF3DDB66C67C
+ 2E7B6900E69F32CC2D9A94A6F278AF33F273E7A99411B360BA6FBF938045F547
+ 7406A14E62EF2FA3951762C0D26F139E8EF9DB4D7F60034EF53F7BC0E80B8934
+ 7CFDEF27F4D42383056FD797691E94146709DE502A2C7C7867F189757408DC32
+ 269455099E0B5C70654A98801835C35E8F33F22AA602C58400F250A340A913A7
+ B65F4BE6BC79BEF2C5FDD592E210FD02BC4D3C4BC7B7F58C30019B4F3819E874
+ 5515FCA4178C4CCDA4BF5D0AD379AECC9AFE97E342392C7292F42147BBC3128A
+ 26397A4A2EF25C1E678ED8024B1CBF5702975728753F2F177710969F55D44EB7
+ BE2572139454B05A9D85D45B7CFC5C062D984DB9FD8B57D0F903E568E6460B7B
+ DC95764B0297B6C475C904CF3E0DADFCC24A1597CE86D6E1C919481D62E2515A
+ 5722C8A1C53D1906E6207D67E2991BCB5E69DA250EE3B5BBE66D843309547065
+ 9C22CFBFF4750FE5A3F6EB4E21EC3C3BFEF0D0BDD79CAD89E30C1E727A024AC7
+ 8B9AB1DB7D23BD01559734E64574120A3AC04EB5512FBEC6CE82D7C6E632E834
+ 5D420E5A597681E6DD1BEDEC86268F04AF8286A2CB068D73460B0CE5C62500FB
+ 3E761540CC25EA34AE8E44C6BB708DE7C98730A83A713BD7002B6B86793EC3FF
+ 248037F1C7626C034E7743C401A724220167DE5C2172012F749B515F7F043E0B
+ D2143582BBD8E4587B5F1D8C1D834B3D1DB5850FB9625C7BC4746E581BE32441
+ A539C707455106EA4DB669219AD2A91B9012701E46FE4CD41F368921B52D3E0D
+ 289950EA026676FC650A6F2F01206BD677366FAC2290364AAC464B32CA886167
+ 0512C7BD444C5730AEDD0736DFC339F8AE1176EF7969F1E918BD4B5E685E43BA
+ 3457C92714CDC96D30B97EDC5C4813056DBCF38CF7925FD6FBACDF3663741411
+ 678F1352AF221CE5C74A278C6DDCF645BB9F377373FC5DDE005304D0194AEDB4
+ AE15F5B66D9AE2897F0CE9D4FCF9EFDD098AB272EC4CE618FF94FE8268C362EA
+ F2B9727EB5210A3D86D0CF7D31D06B7834DA42BF825B1C14FE65442EDA122F7F
+ EBB508CD43CA9DACE2A813BF5048AAD50E19B90559F1C466077AA6765D9549C4
+ 0AB13AD7DD13D30EAABC842C0BB36B67EC36FC7EC8B1309671DADD928184899F
+ C26D8735C8780AB0F7C64D980E799766FB7E14AB834C0D3D921384DC786B4C8C
+ ADF9677D0E208C2D98D72ACC3D2EE236FA20C85E75305E615F469F5E8C14981B
+ 23F7370E4F0F3AA8C6122C4209DA2AB76391E19483F76E46BD51EBA1F4ACC270
+ 21C1BF8EFED1B8B797BBAAE0AB2643524233E3E68F0AFABBCD2E00DA151527BD
+ 0A48EAB02929A80918914668AAF01BEE63F8726086A0DEB573071E167638873A
+ 3C16D55B1789E7569B1F1014918DCF6C864D66C1DEA26C2EE6E43B3DC48D62A1
+ F94E13DE0CB7E6A1DE618E0F09230F44CDFC0CE589FDB82853C92D29BB4E72CA
+ 3CA2C2CF9718E5853835022E0F489AB66A6A8724CA841D905AF48CE2111DA8EB
+ 2BCFB987DAE79AEFCF7EBFA198EF8713039CD043071333AF695703F8183EEA95
+ 7D6C23D58E98803CE6A2CA69562D50461BBCE6FBFCC835CD1B81B29858504061
+ E2D197B0CFD0C0EC6B88EDB9EBFBE29132B93DD5E0A041802278E9ABFF391780
+ 0D8EEBDBCF09BE24DCA3CAB61E0D6104C01A53987EE84C8B0CCDAAE30E166286
+ C54C5F58D3D459B328E70E6B4BEF4C987DE7D4CC3DD9E057A6800FDDFDA3F0CA
+ 5E71FE4B651FBE3B06E3B1F58CADD9B9E711ED238D9711D82ECC2AB5CD101D75
+ 01C2041209CCE11C1C07DD32BB9876F202AC0ABF995504BC2814EE1171F02E33
+ 805EA7D9149E37C565BECC4EB97D5083BD1BAAAD8F843311E2331E4C1C52EA87
+ 6E9F0572C79B0A080A8D16C6CA5EAA075B46A2A83FB9B1B7FC5E3E0CF1DAF9F7
+ 476C127BA432EAEC49F88BB99C0F58A100B192693E0731210AE3FAFF8339AA80
+ 57574F87E48E7F26F02C1CA1D4B059EECACFA0987E6C270A67B828B1339114C2
+ 9E3E24DC5FBAB604307C5A629C4C287ACBB8E882C5E2F806D9A0893124DF53BA
+ 5844647688E067EB643F232A6C7D44EF206B486244F3DE7829CBD87AEF65D527
+ ACC4598E93A493EFBE15C6F2481285CC4F8B36E4376E023C370744B10A1929A2
+ 0A6B234D7DF7FBAA423C3DD72CFC8AD2580E63F72085C6017FD24E640F93802B
+ CEA29ECDED208D9190788036E0F344AA01712EEB48E713B9F3B27D73F266A26F
+ 2549E4E672F10ADB607824770817DB468E73D2C2B5EA20A617FAF0B2D80AAAAE
+ 2965486D375209EA5FCE0EA0EB24B9E30ECF40945FCBB62662AAE964F2AE6175
+ 6516222C3E60B773A633F6E003676D6365AD8386C520727CD9F935C64D45AC5D
+ 73E3561D0C23C268D43B7331B6F4342EEC845E4FCBCC73360876ED3D9389976A
+ 5520C6CA9BD58CB1BF91FAAD7CA4D4C81C3EE2B3009B1F0B7CFB1CA3644936F3
+ 7E6C5AB795A1BB6BC6E962F8CD86FF24403E0854EE4B0E79EE7415C561DD9090
+ CE6FACCDA34A8D1A6DD1A3038095E964B8D3E1D0D0EDF1F4641DA636D669AFC1
+ 9BB252015A235EEE772F9ED8321FC1D672B78C24A2D673F1A5EA9B4B881BBA64
+ 36BA5FFD3EB6AB312E0A5BA06B85ECB3E6119E478A1B05D5195DAFCD14A81C81
+ C6E765D3A5E0CB631BE4366EB182979566D3E4A1F369BDDF2ADB2B839EE60590
+ 078F16CE329BFD63152CEC7F1283D810F0EB27F3AA5A7B6842C804D2F9BCCBB8
+ 203A14A5E39E8CBABC07CBEEE11FE72A8D859956733F613C5BD9C82A6811B8B8
+ 4ABB2895C6B8DDD4F65E6ED0FFAD2DAAC3E276023B20FFC10A894AA394DCF970
+ CCD2A4FA6B1B98392D7320F1DAECF6FDDB1F59F8379715F499BB03B6EB07BEFD
+ 26017B478E454924E61C9BEA9615BA47259EE50C717CAD46B0FF5BEC34659156
+ AF170EE936617A5308F365BD944D62746AE4DED312BB931B5105EE0BA07810CD
+ B93267E943E88449C4B3D67CA051FC61F65667860AF96619D6694A026B3F0177
+ 359CA2A7E315434FCA3D3CB124E95EF30A1C671000699E19E4591964D92A14DD
+ 049A86430A6285F573FF62A2448757B9D68114ADC40190A7696A3F1152972866
+ 055A6F897A594A5480EE968979515EE678641837736280CAA5B16171156DEC5A
+ 98623A718A291B7751D9998AF0A6968F11F1788D8BA93B341344958075B14E91
+ 08067DED8C2AA36EFC1E39F9A374E54F9CF8CC5044448945CD4DD3B344F69B09
+ 7EDC76ED34837E9FC9074E2ACA1D753032379DBBC84B38D48D35466B23AEE8CD
+ 1DE3C46AE242A26F6E8D50304DA3FE3A59506D19E9AE01F1D824FD2A672C4185
+ EA029E9763EAF2FDC27642F22BB1B80ED48FCAC22C8D83F33DD63FEB1D1BC517
+ 23157422CB9834C195377B72AE24637650546175F1462EBB38A092E2EE76D578
+ A18EB88CDDA06F59326E17C7A75A320FA3FED936EC375DAF64F879AFE2B6C99E
+ CDF1FD50D382FDBF53D1F6B6F5D366D779DE916F925BAD3A7B3E102ADAA68ABA
+ FD76D464BD48A531DBC4DE15F2DAA7B84BF57F320371C073F709F80327F74A18
+ 53F6E7A375C782149B02B7FB2BDD200A6339E9157964136A727C81408DDEF0B3
+ 736B6FDB582B2ACBAAF6050419A053B96B421381BE7E17B80701B4B399E15C82
+ 7F1E24749ED14A54FAD568FE080662D4FDE7AC62EBF482EA13DD59E2E5F788A5
+ 07C273215BBA4549F04DC2102616F8E035709AC8403B19D8D1E909E9C82E3283
+ 9BE45215533E1275809B81DF21A69E9C7F6EE5F57D695C5968A830C8A2D748C4
+ 0225398142D28188CFE3FE1EC8A698EA99BD37B7DDBA3F4BDD5CCCE8D169F30D
+ 08DA9ADFDD0D048BC9947848F948288EFBC65C7BA30F51C73EBCC9E22999518F
+ 87E42525AF36D31EE2F9E070C27EE145A089CFDB2546CED205DA5350B54E1CDB
+ 32418BFE93A2707AEF5B959AB39DEC2B48A97378308B1B6D27D095FC8F1F055C
+ 713FBD2C32ECDE04AE542EED162C345EE25B613F2378BB7A7CFA93453293D930
+ 84C68DE0FD514B9850FFFB9CA1095FD42A3B5796A5B5F18F6909A224993C31D6
+ 05A7B464BAE339B9202F5C4BEBF48DF8ED02A19F601A1338F9D0AAE3246B0C86
+ A1D1D4B4508D02B3EDFCDF3E2B178B2CC57E241585C2FFA941A6F1BEAF48E419
+ 5F5BB1A467CECE15D0AC7EF64E8DE9E2423799C73D49AE6314C748A505B73B28
+ DD462A07084DD0035892F01CC54EDBECAA6ACEF0DEB3EAC06164CC6C42B05E9F
+ 141491F04C7F2C5705866C7C5EB45BE236BC22A635F89B95CC8F481400E58F20
+ 1D86C24B5EE12F4786327F551EAE77B29417205BE57B5FE116791ABA229D0004
+ 2FDA1F67B81D0BBB3BE5DE32516820990E91901CBB68E5E0C2F7A8DE85008D6E
+ 521C67F4027438B289B615EDFB4A472B0D4D1B83D22203F0631F455D3279712F
+ E0F2958A92394549B993102B54B1EA538B3AB20E2023E83EB2F84C9AE6EA75F7
+ EBF5C8A467237F76DC28343BD2D8718D3016BBD8BC20CFD0F0AF881197D6438F
+ 81244B1DD969893B5D1A97BC7AF4AFDD7DCC9876E89FA704E7909D27667163FE
+ 9A6F1E99900B8C290685BB9341977D7126F4A4787FDAE7E478AE04C990A2B070
+ 6E33269C0502DB2AD97D8C745F07007C0266D0B686807A578FC4E9DF6EAE56B0
+ CEAB08038818C1A00795CB337993CCB392FDD92A645D7D1A680D067875E6D3DF
+ 2AA149044C5ECD853E95951B954575949A4B55B0A39DEA47E78362DD02754A95
+ 9958B6D646BD87ABB705D151CB3880F19BB63D0F83BE350D92DAF795321DED0B
+ CC23BF45A91AA2354665F9CFA2F5207CEDEC7D455AE6E8A7FB6DA83A3A445D14
+ F7A7465BEBE6F173873A1E87772025EF2E9398555A2648DA1472E164D73DDA0D
+ 8DC6ACCD65D96A3A705AF18D9FE9E480D3044AB8E10381ED802C83EF4DEAFD8E
+ 91BED74DC5C469D6ECB1F341F27FCFB357A88C753BC287BA5F6C17D411940330
+ 73D3B72FB25CA7BA050FBAC8109667C3E543778B15CFA6FEC2A09BB4B726BE69
+ 49C5CC3A4152D48144255C4D289E06D8FCF3259093B594B159EA5C4D0318D485
+ C3CB7A0D04F66767798C888E70C4F4293D87E55E9FB2ADF046B55200639833FB
+ 5F308F8B384A3CA43D49A320DE491E622906B631BFC8721AC8DE75E9DBB5E333
+ 9E715443B8C8208235E405EE52CBB461E4A9C972D107C32AA96DE99E430E0E92
+ 2A8BBFBE5ABC5B6C746ABC4962D09337A09AA393BDFA96E204B07163D97C29D6
+ 85A90C8656C4E793984AF59B407AB386F0EA33D14E97FD4EEFB405A2BFA23DBA
+ 48C60B7264CA0530303281D4C322E7C3296C02D443DD6526CAC6AADCC177C110
+ 01AE5F3C8DF072B8F1007EA11B8A6A70229120F0B1777E2A15D50C66F6FB9CD2
+ 44E010676F323393580E193E08719F500C4F826E41464981EC03610B5F83A591
+ EFE25AFD9D229CEDC2E3B0B49CB585C7C3A6BDD0DBA6BFA1DB6B8ED902B5B175
+ 700F8DCACC13D1B63FB3782E4C9ED619F62916D3DFD19DD1F611E094B2B295A5
+ 9C74E23C16E9915CD8D0DB3A851B69E00B700A00DC5A9778FC182608DADFBB4D
+ DDAE36293A84B8AF634D15D214309DB2C4C6F8FB1CBFE270219850F923BE5B91
+ 0B748E1B67CE1438F4498EA23F273EE97294111458710BCD7A32218ECB957F80
+ 3929D15127606F15C3E11CD05D6ABD93ECCA9EF2CD62B68FB4FBFBF323ADCC9D
+ 523C22A5C5C69685BBB19EF32B76B233F98C2154AAEE2A391B476E68FCE976DB
+ E8B4419C1B749C9A15097072A20918E5EE109089030AADC252C0E131F4475259
+ A1B5D605A12B16716D7020FBA0A45AC39712AD6AEE8AFF7EC2100E26A211058D
+ 03EE247F7E69D39F7130C795E26EE09086447F99916E3C07A1A24106421C4A5C
+ 1901AB0776D0E1B55DCB2F49A71CDF1E7E6B1E78D8118B672C968C9312265286
+ 78EC4162F5000A0D791B44CCF8A1FFF4F141BA3477E366188D2D7659CB22A897
+ 6D9A471B6F16EC16DA857DB40E0F48BD912D96571F2F963D86A173E4472F55DD
+ 1208DF07715D33DFF00C664227F6E30A4166BD3619E79A0D64C0754629ED445C
+ 7D79F583278F1656982C4E879B8F9D6E13D7D44FFDD7E420D642BD324106840D
+ 9C20F3EC0B4260963FCD9762AF9A29B64AB071F5F7F970FB7D8B8498ACD2C786
+ 2C8748D4FB934AA97C9823C52F1E36E35B1CDA1C98C3D84F1F3FBC73397F316E
+ EB64A41B14DFD6F9BA7CA561FA0AD0E502325BC582B5E3A1757414662D9ACE54
+ 316399E2B506CB85047C77F411D31610CFFD62AF623BCE049453ADCA81ED9E93
+ C478F42B614BEDFB743B4E69D72578D9DFDC32E0E0F496C881F8204C92A333BC
+ EC720CF64656001773BD42DA747250B439BF6C8CB6565E00EF714839876A4231
+ 5A991379494A2AECF79559DF45082F0368DC78A40156F1A8D7B3225B75EF70E8
+ C0140B3D59C71BCF5503A92C801CC9CA4C5561CC0E7F26B03808109B3A0E5204
+ 89D8E898F0557A2B780DD9EC2452A0C6643990E6D4ECA6F0ECC03CA43B39F9E7
+ 8A3B647D14BEF0434E66453E5E596E0E6CE74CFD8D4F09D219441063EB8180B0
+ CE96D78932C8C781AB1CF5FAD4CED46043675E19CCC06855871243BEDE14F169
+ 03CB5DF46D2C2C59E54A750CAEE9B60A2FDF5CD4DD0011E1BF9FC1BD6765F448
+ 24EA05C1E0631AC96C85C6FCB6ED17C2606574B0F03D697329F0FEC1A1F05276
+ 5A37BDB5F9F50DD65A5356AF2998AC3F9449B6E0623A20EF8896F5AE56357081
+ C42F8B5C093F9611A04CF6CBB74E9A39A89FEFD65E6462334010B4B7FFCB33D2
+ 376C6758ED38315D928902796772A9B7C7B814026EBD54CE1E161D3F5CDED849
+ F3BF2E85495C0E63BE196E2997502DF20A9BBF66B2A07AAA5C4B400A91E090EF
+ FC6FB2B0E8D5463DDC02A19371C6336CE9D38CB0EB87801E7E923A33689A2FBA
+ 1BDC5FA32DC829D65A06A78F927F6CE6C265158DC6253C71678850360E0ADBB6
+ 25BA6B5703D2DE43E4D9082A88925EC22C6C36929C77EBBA66367696CFC09614
+ 713BE610B497A60990524D1C2A891C4ED3A92091D7A6F1DE2970B355E90001E5
+ 763F1EEF4090AC77BC80893D0FCAE0EEAD6DCE05663047C7A81FF5080C5DBA9B
+ 4D980E678A21F1F4A2F49A1AFA5689EE1C0461EA51832593B15438251C439E1D
+ 5B6A3241A57254C59BF9C555A498DA047F047FBF0E94A4917655BA9B1990E7D3
+ 2CD81EE10FAE05B9805FA63A9EBF7F089F4A7CE4F14AE327FF044EF4BF4A6B62
+ AD00B5FED85930518F47CEF67A4BC750F32AC49AF87F6ABF62E8BF68B8DD2751
+ D648CEBC80953CE3A4D3FE75150AEB3AD318BFA187ACDA5C132A9E54A7EEBC52
+ 0C5DCBD810FAE313AAE4DF93541594BD44A0A2070DBADEAA4A478CE5FCA4BE1B
+ 4359AD1D64D85B9665E3C41EA84F64CFB68007D51ED4A715E138841E082C6374
+ 6AC8C5954B7F0C62F5E395661A260BBF71FAA7153E59388A18D145D26BB8DBFA
+ CC531BAB0FDCD2F623FB802A3F0524BFEEB77609A7009FE2C275F41B7019C686
+ E0963D793208BAED9AA2F91EDFFFBC059FBF4BA66875293850E56F47B0308842
+ CAB4E928B42070557EB78F31433D35BEA7F0FC84898E9ADC98BBC133985BBC02
+ ABC2584916529E5F531BF53B1C323970E8B325F4B7DE5AB362EBD3ECA7198A2D
+ C473C393F2A6C2FCE5F822ADB74F00BC8D5478F2FBC039190E9E81014E6E43B2
+ 5E8F162F80F43BFA8D8720C92EE17F5C7A45B4A4E08611DB53C0E417C513041E
+ E1D9F29A6BFC8D2EDDC6752D5C9C228ED973E19D9610F9BE7727E039C69D7E08
+ DB44E2574D45585BBE6CD2B98FA1452916AC968A6B6D18BEEBCBB38B299D69C6
+ 98A360F30BB34CDA26D8EC4D515E5BBEEAE4A8193AEF12300433E2C7562F78DC
+ 5035BDC54E208F0D9BF370812AE714A70173FEE1FB40AAEA25171E204608E318
+ 45AA675336DDAE74DFFA66D5FBC048E84FD86C4932DF305E17AF2C321B66ABA1
+ DE6A2EA2EA88D6985DDAF510FBAEAE4F0D7C44841D3E77204A9E398BA57E1950
+ D88F0D3C4B0F491C19079BA97DB5667E447B4012B9A648523C0B2C5C5FE4CE80
+ AF3DE3F9388F0D00447465B6666A96D577AD610575B60CFECD7B45CE0299042D
+ 33CDA5FE6837FD8F0182CFD3CB3FEE8A9BBC293534039CEC7296554A08B78D37
+ 575B69721EB73CD7B412F7927B0633C55DE86F0B8437429F7F59EAC5504C46E1
+ 0E8D3AC90975F66428BBE23E3D3EB98AEEE5357A20FA1CB71656286B3F68C914
+ B185C79CE2108DF4161AE6B39954741A1F69B9FA589BBA1B4C790BC8ACE5A4B5
+ 350D42E61DEC1810FF7B9836A4CCE8ED0228C975ED2AD13E4E6BBCCF099C919A
+ 0466CCD0F008D2D9F414123D552507ED64229DD3C98E777F372FAF175DCCA933
+ E1A5E82663BEA6D3AC3B3EBC90E30EF8F1FE6E5110438C8B32B66F8FF756B5AF
+ E863F93C055B5683CFAB6AFFEDA42E99844D254736944625BFA2C3750ACBF5E2
+ 54348B150DA0777B6CC7A43D872E058219866CF3971E8F175751A3933647E89F
+ CE77C50E3C5E9897606595A5B1195B478D1F3D4F78E73843EFA949BC2AC8563F
+ F1DE88E3BACB36576E8B8A9C9BB31B19B81F667CC915D134204985A6A458EEB6
+ B38E315A76158193942BDC92C440DC5EE7B0704E80E979041D1028CA4AC84EAE
+ 275F42662868291DACCC3880503232D346720C1E2A1B0DC020266F08827AE29D
+ 167C14A226AEE569C859A2EDDA2B595A8184358C87186D3BC32BB8918D4FB7B2
+ EDB081DAC966168EDDF09EE93D99951BE714AAACD61D7B4225274C1C66B834BF
+ 8633A118065C2F6F23ACFA6FD775417CBDD79175E0073C8922C7EB340C836EAC
+ CA09129F0AF464EE5FB15A4C1C75C209C1337261CDD537B58C7BF8E139640EAD
+ 8C60AF75B4D06DCA4E41C25FE1BAD4D4CDE66CE111BCA81C4E4ED28A91D97C83
+ A5F250798391537A59302CEDD32C44FFBE778CA28329DBB76770801BEB3B4063
+ 1AE07008AD6A16353C8A23D4AFD9E69F434FFB8BFB011BBB425758564302B40C
+ 6E564374D8BA71BDE34650D5DC6C7F6B297BA313181392CD5C6C5786E6910232
+ C66D9ABBFE164819980EA2E487A9BE843C9BE1149BE6F568CA7B2F0030628D7D
+ 1255F0775CE08AB2A05AB696D3D23AB5EFE2604E8DCB22DC999A7BFF207A92D3
+ C4E71F680683A37E2085C9C7D04FE0575903AFDD1354A55F18B8138340534015
+ 01302A
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ /BAAAAA+NimbusRomNo9L-Regu findfont /Encoding get
+ dup 127 /.notdef put
+ dup 32 /space put
+ dup 33 /exclam put
+ dup 34 /quotedbl put
+ dup 35 /numbersign put
+ dup 36 /dollar put
+ dup 37 /percent put
+ dup 38 /ampersand put
+ dup 39 /quoteright put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 42 /asterisk put
+ dup 43 /plus put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 47 /slash put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 59 /semicolon put
+ dup 60 /less put
+ dup 61 /equal put
+ dup 62 /greater put
+ dup 63 /question put
+ dup 64 /at put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 74 /J put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 81 /Q put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 87 /W put
+ dup 88 /X put
+ dup 89 /Y put
+ dup 90 /Z put
+ dup 91 /bracketleft put
+ dup 92 /backslash put
+ dup 93 /bracketright put
+ dup 94 /asciicircum put
+ dup 95 /underscore put
+ dup 96 /quoteleft put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ dup 123 /braceleft put
+ dup 124 /bar put
+ dup 125 /braceright put
+ dup 126 /asciitilde put
+ dup 161 /exclamdown put
+ dup 162 /cent put
+ dup 163 /sterling put
+ dup 164 /fraction put
+ dup 165 /yen put
+ dup 166 /florin put
+ dup 167 /section put
+ dup 168 /currency put
+ dup 169 /quotesingle put
+ dup 170 /quotedblleft put
+ dup 171 /guillemotleft put
+ dup 172 /guilsinglleft put
+ dup 173 /guilsinglright put
+ dup 174 /fi put
+ dup 175 /fl put
+ dup 177 /endash put
+ dup 178 /dagger put
+ dup 179 /daggerdbl put
+ dup 180 /periodcentered put
+ dup 182 /paragraph put
+ dup 183 /bullet put
+ dup 184 /quotesinglbase put
+ dup 185 /quotedblbase put
+ dup 186 /quotedblright put
+ dup 187 /guillemotright put
+ dup 188 /ellipsis put
+ dup 189 /perthousand put
+ dup 191 /questiondown put
+ dup 193 /grave put
+ dup 194 /acute put
+ dup 195 /circumflex put
+ dup 196 /tilde put
+ dup 197 /macron put
+ dup 198 /breve put
+ dup 199 /dotaccent put
+ dup 200 /dieresis put
+ dup 202 /ring put
+ dup 203 /cedilla put
+ dup 205 /hungarumlaut put
+ dup 206 /ogonek put
+ dup 207 /caron put
+ dup 208 /emdash put
+ dup 225 /AE put
+ dup 227 /ordfeminine put
+ dup 232 /Lslash put
+ dup 233 /Oslash put
+ dup 234 /OE put
+ dup 235 /ordmasculine put
+ dup 241 /ae put
+ dup 245 /dotlessi put
+ dup 248 /lslash put
+ dup 249 /oslash put
+ dup 250 /oe put
+ dup 251 /germandbls put
+ dup 0 /Adieresis put
+ pop
+ end
+ %%EndResource
+ 
+ userdict /pdf_svglb get setglobal
+ [/N8/BAAAAA+NimbusRomNo9L-Regu -1 TZG
+ %%EndPageSetup
+ 0 0 612 792 re
+ W
+ n
+ 0 w
+ q
+ n
+ 0 -0.0999908 612.1 792.1 re
+ eoclip
+ n
+ n
+ 110.2 658.6 m
+ 163.1 658.6 l
+ 163.1 560.2 l
+ 110.2 560.2 l
+ 110.2 658.6 l
+ h
+ [/DeviceRGB] cs 0.752869 0.752869 0.752869 sc
+ 
+ eofill
+ n
+ 142.5 618.9 m
+ 112.2 559.3 l
+ 24.5 603.9 l
+ 85 723.1 l
+ 172.8 678.5 l
+ 142.5 618.9 l
+ h
+ 1 1 1 sc
+ eofill
+ n
+ 368.5 658.6 m
+ 421.4 658.6 l
+ 421.4 560.2 l
+ 368.5 560.2 l
+ 368.5 658.6 l
+ h
+ 0.752869 0.752869 0.752869 sc
+ eofill
+ n
+ 389.1 618.9 m
+ 358.8 678.5 l
+ 446.5 723.1 l
+ 507.1 603.9 l
+ 419.4 559.2 l
+ 389.1 618.9 l
+ h
+ 1 1 1 sc
+ eofill
+ n
+ 485.6 560.6 m
+ 471.6 565.2 l
+ 471.6 555.9 l
+ 485.6 560.6 l
+ h
+ 0 0 0 sc
+ eofill
+ n
+ 113.9 560.9 m
+ 474.4 560.9 l
+ 474.4 560.2 l
+ 113.9 560.2 l
+ 113.9 560.9 l
+ h
+ eofill
+ n
+ 113.5 718.9 m
+ 108.8 704.9 l
+ 118.2 704.9 l
+ 113.5 718.9 l
+ h
+ eofill
+ n
+ 113.1 560.9 m
+ 113.2 707.7 l
+ 113.9 707.7 l
+ 113.8 560.9 l
+ 113.1 560.9 l
+ h
+ eofill
+ n
+ 163.1 679.1 m
+ 163.1 677.7 l
+ 162.4 677.7 l
+ 162.4 679.1 l
+ 163.1 679.1 l
+ h
+ eofill
+ n
+ 163.1 676.2 m
+ 163.1 674.8 l
+ 162.4 674.8 l
+ 162.4 676.2 l
+ 163.1 676.2 l
+ h
+ eofill
+ n
+ 163.1 673.3 m
+ 163.1 671.9 l
+ 162.4 671.9 l
+ 162.4 673.3 l
+ 163.1 673.3 l
+ h
+ eofill
+ n
+ 163.1 670.5 m
+ 163.1 669 l
+ 162.4 669 l
+ 162.4 670.5 l
+ 163.1 670.5 l
+ h
+ eofill
+ n
+ 163.1 667.6 m
+ 163.1 666.1 l
+ 162.4 666.1 l
+ 162.4 667.6 l
+ 163.1 667.6 l
+ h
+ eofill
+ n
+ 163.1 664.7 m
+ 163.1 663.2 l
+ 162.4 663.2 l
+ 162.4 664.7 l
+ 163.1 664.7 l
+ h
+ eofill
+ n
+ 163.1 661.8 m
+ 163.1 660.3 l
+ 162.4 660.3 l
+ 162.4 661.8 l
+ 163.1 661.8 l
+ h
+ eofill
+ n
+ 163.1 658.9 m
+ 163.1 657.4 l
+ 162.4 657.4 l
+ 162.4 658.9 l
+ 163.1 658.9 l
+ h
+ eofill
+ n
+ 163.1 656 m
+ 163.1 654.5 l
+ 162.4 654.5 l
+ 162.4 656 l
+ 163.1 656 l
+ h
+ eofill
+ n
+ 163.1 653.1 m
+ 163.1 651.7 l
+ 162.4 651.7 l
+ 162.4 653.1 l
+ 163.1 653.1 l
+ h
+ eofill
+ n
+ 163.1 650.2 m
+ 163.1 648.8 l
+ 162.4 648.8 l
+ 162.4 650.2 l
+ 163.1 650.2 l
+ h
+ eofill
+ n
+ 163.1 647.3 m
+ 163.1 645.9 l
+ 162.4 645.9 l
+ 162.4 647.3 l
+ 163.1 647.3 l
+ h
+ eofill
+ n
+ 163.1 644.4 m
+ 163.1 643 l
+ 162.4 643 l
+ 162.4 644.4 l
+ 163.1 644.4 l
+ h
+ eofill
+ n
+ 163.1 641.5 m
+ 163.1 640.1 l
+ 162.4 640.1 l
+ 162.4 641.5 l
+ 163.1 641.5 l
+ h
+ eofill
+ n
+ 163.1 638.6 m
+ 163.1 637.2 l
+ 162.4 637.2 l
+ 162.4 638.6 l
+ 163.1 638.6 l
+ h
+ eofill
+ n
+ 163.1 635.8 m
+ 163.1 634.3 l
+ 162.4 634.3 l
+ 162.4 635.8 l
+ 163.1 635.8 l
+ h
+ eofill
+ n
+ 163.1 632.9 m
+ 163.1 631.4 l
+ 162.4 631.4 l
+ 162.4 632.9 l
+ 163.1 632.9 l
+ h
+ eofill
+ n
+ 163.1 630 m
+ 163.1 628.5 l
+ 162.4 628.5 l
+ 162.4 630 l
+ 163.1 630 l
+ h
+ eofill
+ n
+ 163.1 627.1 m
+ 163.1 625.6 l
+ 162.4 625.6 l
+ 162.4 627.1 l
+ 163.1 627.1 l
+ h
+ eofill
+ n
+ 163.1 624.2 m
+ 163.1 622.7 l
+ 162.4 622.7 l
+ 162.4 624.2 l
+ 163.1 624.2 l
+ h
+ eofill
+ n
+ 163.1 621.3 m
+ 163.1 619.9 l
+ 162.4 619.9 l
+ 162.4 621.3 l
+ 163.1 621.3 l
+ h
+ eofill
+ n
+ 163.1 618.4 m
+ 163.1 617 l
+ 162.4 617 l
+ 162.4 618.4 l
+ 163.1 618.4 l
+ h
+ eofill
+ n
+ 163.1 615.5 m
+ 163.1 614.1 l
+ 162.4 614.1 l
+ 162.4 615.5 l
+ 163.1 615.5 l
+ h
+ eofill
+ n
+ 163.1 612.6 m
+ 163.1 611.2 l
+ 162.4 611.2 l
+ 162.4 612.6 l
+ 163.1 612.6 l
+ h
+ eofill
+ n
+ 163.1 609.7 m
+ 163.1 608.3 l
+ 162.4 608.3 l
+ 162.4 609.7 l
+ 163.1 609.7 l
+ h
+ eofill
+ n
+ 163.1 606.8 m
+ 163.1 605.4 l
+ 162.4 605.4 l
+ 162.4 606.8 l
+ 163.1 606.8 l
+ h
+ eofill
+ n
+ 163.1 603.9 m
+ 163.1 602.5 l
+ 162.4 602.5 l
+ 162.4 603.9 l
+ 163.1 603.9 l
+ h
+ eofill
+ n
+ 163.1 601.1 m
+ 163.1 599.6 l
+ 162.4 599.6 l
+ 162.4 601.1 l
+ 163.1 601.1 l
+ h
+ eofill
+ n
+ 163.1 598.2 m
+ 163.1 596.7 l
+ 162.4 596.7 l
+ 162.4 598.2 l
+ 163.1 598.2 l
+ h
+ eofill
+ n
+ 163.1 595.3 m
+ 163.1 593.8 l
+ 162.4 593.8 l
+ 162.4 595.3 l
+ 163.1 595.3 l
+ h
+ eofill
+ n
+ 163.1 592.4 m
+ 163.1 590.9 l
+ 162.4 590.9 l
+ 162.4 592.4 l
+ 163.1 592.4 l
+ h
+ eofill
+ n
+ 163.1 589.5 m
+ 163.1 588 l
+ 162.4 588 l
+ 162.4 589.5 l
+ 163.1 589.5 l
+ h
+ eofill
+ n
+ 163.1 586.6 m
+ 163.1 585.2 l
+ 162.4 585.2 l
+ 162.4 586.6 l
+ 163.1 586.6 l
+ h
+ eofill
+ n
+ 163.1 583.7 m
+ 163.1 582.3 l
+ 162.4 582.3 l
+ 162.4 583.7 l
+ 163.1 583.7 l
+ h
+ eofill
+ n
+ 163.1 580.8 m
+ 163.1 579.4 l
+ 162.4 579.4 l
+ 162.4 580.8 l
+ 163.1 580.8 l
+ h
+ eofill
+ n
+ 163.1 577.9 m
+ 163.1 576.5 l
+ 162.4 576.5 l
+ 162.4 577.9 l
+ 163.1 577.9 l
+ h
+ eofill
+ n
+ 163.1 575 m
+ 163.1 573.6 l
+ 162.4 573.6 l
+ 162.4 575 l
+ 163.1 575 l
+ h
+ eofill
+ n
+ 163.1 572.1 m
+ 163.1 570.7 l
+ 162.4 570.7 l
+ 162.4 572.1 l
+ 163.1 572.1 l
+ h
+ eofill
+ n
+ 163.1 569.3 m
+ 163.1 567.8 l
+ 162.4 567.8 l
+ 162.4 569.3 l
+ 163.1 569.3 l
+ h
+ eofill
+ n
+ 163.1 566.4 m
+ 163.1 564.9 l
+ 162.4 564.9 l
+ 162.4 566.4 l
+ 163.1 566.4 l
+ h
+ eofill
+ n
+ 163.1 563.5 m
+ 163.1 562 l
+ 162.4 562 l
+ 162.4 563.5 l
+ 163.1 563.5 l
+ h
+ eofill
+ n
+ 163.1 560.6 m
+ 163.1 559.1 l
+ 162.4 559.1 l
+ 162.4 560.6 l
+ 163.1 560.6 l
+ h
+ eofill
+ n
+ 163.1 557.7 m
+ 163.1 556.2 l
+ 162.4 556.2 l
+ 162.4 557.7 l
+ 163.1 557.7 l
+ h
+ eofill
+ n
+ 163.1 554.8 m
+ 163.1 553.4 l
+ 162.4 553.4 l
+ 162.4 554.8 l
+ 163.1 554.8 l
+ h
+ eofill
+ n
+ 163.1 551.9 m
+ 163.1 550.5 l
+ 162.4 550.5 l
+ 162.4 551.9 l
+ 163.1 551.9 l
+ h
+ eofill
+ n
+ 163.1 549 m
+ 163.1 547.6 l
+ 162.4 547.6 l
+ 162.4 549 l
+ 163.1 549 l
+ h
+ eofill
+ n
+ 163.1 546.1 m
+ 163.1 544.7 l
+ 162.4 544.7 l
+ 162.4 546.1 l
+ 163.1 546.1 l
+ h
+ eofill
+ n
+ 163.1 543.2 m
+ 163.1 541.8 l
+ 162.4 541.8 l
+ 162.4 543.2 l
+ 163.1 543.2 l
+ h
+ eofill
+ n
+ 163.1 540.3 m
+ 163.1 538.9 l
+ 162.4 538.9 l
+ 162.4 540.3 l
+ 163.1 540.3 l
+ h
+ eofill
+ n
+ 163.1 537.4 m
+ 163.1 536 l
+ 162.4 536 l
+ 162.4 537.4 l
+ 163.1 537.4 l
+ h
+ eofill
+ n
+ 368.6 679.1 m
+ 368.6 677.7 l
+ 367.9 677.7 l
+ 367.9 679.1 l
+ 368.6 679.1 l
+ h
+ eofill
+ n
+ 368.6 676.2 m
+ 368.6 674.8 l
+ 367.9 674.8 l
+ 367.9 676.2 l
+ 368.6 676.2 l
+ h
+ eofill
+ n
+ 368.6 673.3 m
+ 368.6 671.9 l
+ 367.9 671.9 l
+ 367.9 673.3 l
+ 368.6 673.3 l
+ h
+ eofill
+ n
+ 368.6 670.4 m
+ 368.6 669 l
+ 367.9 669 l
+ 367.9 670.4 l
+ 368.6 670.4 l
+ h
+ eofill
+ n
+ 368.6 667.5 m
+ 368.6 666.1 l
+ 367.9 666.1 l
+ 367.9 667.5 l
+ 368.6 667.5 l
+ h
+ eofill
+ n
+ 368.6 664.6 m
+ 368.6 663.2 l
+ 367.9 663.2 l
+ 367.9 664.6 l
+ 368.6 664.6 l
+ h
+ eofill
+ n
+ 368.6 661.7 m
+ 368.6 660.3 l
+ 367.9 660.3 l
+ 367.9 661.7 l
+ 368.6 661.7 l
+ h
+ eofill
+ n
+ 368.6 658.9 m
+ 368.6 657.4 l
+ 367.9 657.4 l
+ 367.9 658.9 l
+ 368.6 658.9 l
+ h
+ eofill
+ n
+ 368.6 656 m
+ 368.6 654.5 l
+ 367.9 654.5 l
+ 367.9 656 l
+ 368.6 656 l
+ h
+ eofill
+ n
+ 368.6 653.1 m
+ 368.6 651.6 l
+ 367.9 651.6 l
+ 367.9 653.1 l
+ 368.6 653.1 l
+ h
+ eofill
+ n
+ 368.6 650.2 m
+ 368.6 648.7 l
+ 367.9 648.7 l
+ 367.9 650.2 l
+ 368.6 650.2 l
+ h
+ eofill
+ n
+ 368.6 647.3 m
+ 368.6 645.8 l
+ 367.9 645.8 l
+ 367.9 647.3 l
+ 368.6 647.3 l
+ h
+ eofill
+ n
+ 368.6 644.4 m
+ 368.6 643 l
+ 367.9 643 l
+ 367.9 644.4 l
+ 368.6 644.4 l
+ h
+ eofill
+ n
+ 368.6 641.5 m
+ 368.6 640.1 l
+ 367.9 640.1 l
+ 367.9 641.5 l
+ 368.6 641.5 l
+ h
+ eofill
+ n
+ 368.6 638.6 m
+ 368.6 637.2 l
+ 367.9 637.2 l
+ 367.9 638.6 l
+ 368.6 638.6 l
+ h
+ eofill
+ n
+ 368.6 635.7 m
+ 368.6 634.3 l
+ 367.9 634.3 l
+ 367.9 635.7 l
+ 368.6 635.7 l
+ h
+ eofill
+ n
+ 368.6 632.8 m
+ 368.6 631.4 l
+ 367.9 631.4 l
+ 367.9 632.8 l
+ 368.6 632.8 l
+ h
+ eofill
+ n
+ 368.6 629.9 m
+ 368.6 628.5 l
+ 367.9 628.5 l
+ 367.9 629.9 l
+ 368.6 629.9 l
+ h
+ eofill
+ n
+ 368.6 627.1 m
+ 368.6 625.6 l
+ 367.9 625.6 l
+ 367.9 627.1 l
+ 368.6 627.1 l
+ h
+ eofill
+ n
+ 368.6 624.2 m
+ 368.6 622.7 l
+ 367.9 622.7 l
+ 367.9 624.2 l
+ 368.6 624.2 l
+ h
+ eofill
+ n
+ 368.6 621.3 m
+ 368.6 619.8 l
+ 367.9 619.8 l
+ 367.9 621.3 l
+ 368.6 621.3 l
+ h
+ eofill
+ n
+ 368.6 618.4 m
+ 368.6 616.9 l
+ 367.9 616.9 l
+ 367.9 618.4 l
+ 368.6 618.4 l
+ h
+ eofill
+ n
+ 368.6 615.5 m
+ 368.6 614 l
+ 367.9 614 l
+ 367.9 615.5 l
+ 368.6 615.5 l
+ h
+ eofill
+ n
+ 368.6 612.6 m
+ 368.6 611.1 l
+ 367.9 611.1 l
+ 367.9 612.6 l
+ 368.6 612.6 l
+ h
+ eofill
+ n
+ 368.6 609.7 m
+ 368.6 608.3 l
+ 367.9 608.3 l
+ 367.9 609.7 l
+ 368.6 609.7 l
+ h
+ eofill
+ n
+ 368.6 606.8 m
+ 368.6 605.4 l
+ 367.9 605.4 l
+ 367.9 606.8 l
+ 368.6 606.8 l
+ h
+ eofill
+ n
+ 368.6 603.9 m
+ 368.6 602.5 l
+ 367.9 602.5 l
+ 367.9 603.9 l
+ 368.6 603.9 l
+ h
+ eofill
+ n
+ 368.6 601 m
+ 368.6 599.6 l
+ 367.9 599.6 l
+ 367.9 601 l
+ 368.6 601 l
+ h
+ eofill
+ n
+ 368.6 598.1 m
+ 368.6 596.7 l
+ 367.9 596.7 l
+ 367.9 598.1 l
+ 368.6 598.1 l
+ h
+ eofill
+ n
+ 368.6 595.2 m
+ 368.6 593.8 l
+ 367.9 593.8 l
+ 367.9 595.2 l
+ 368.6 595.2 l
+ h
+ eofill
+ n
+ 368.6 592.4 m
+ 368.6 590.9 l
+ 367.9 590.9 l
+ 367.9 592.4 l
+ 368.6 592.4 l
+ h
+ eofill
+ n
+ 368.6 589.5 m
+ 368.6 588 l
+ 367.9 588 l
+ 367.9 589.5 l
+ 368.6 589.5 l
+ h
+ eofill
+ n
+ 368.6 586.6 m
+ 368.6 585.1 l
+ 367.9 585.1 l
+ 367.9 586.6 l
+ 368.6 586.6 l
+ h
+ eofill
+ n
+ 368.6 583.7 m
+ 368.6 582.2 l
+ 367.9 582.2 l
+ 367.9 583.7 l
+ 368.6 583.7 l
+ h
+ eofill
+ n
+ 368.6 580.8 m
+ 368.6 579.3 l
+ 367.9 579.3 l
+ 367.9 580.8 l
+ 368.6 580.8 l
+ h
+ eofill
+ n
+ 368.6 577.9 m
+ 368.6 576.5 l
+ 367.9 576.5 l
+ 367.9 577.9 l
+ 368.6 577.9 l
+ h
+ eofill
+ n
+ 368.6 575 m
+ 368.6 573.6 l
+ 367.9 573.6 l
+ 367.9 575 l
+ 368.6 575 l
+ h
+ eofill
+ n
+ 368.6 572.1 m
+ 368.6 570.7 l
+ 367.9 570.7 l
+ 367.9 572.1 l
+ 368.6 572.1 l
+ h
+ eofill
+ n
+ 368.6 569.2 m
+ 368.6 567.8 l
+ 367.9 567.8 l
+ 367.9 569.2 l
+ 368.6 569.2 l
+ h
+ eofill
+ n
+ 368.6 566.3 m
+ 368.6 564.9 l
+ 367.9 564.9 l
+ 367.9 566.3 l
+ 368.6 566.3 l
+ h
+ eofill
+ n
+ 368.6 563.4 m
+ 368.6 562 l
+ 367.9 562 l
+ 367.9 563.4 l
+ 368.6 563.4 l
+ h
+ eofill
+ n
+ 368.6 560.6 m
+ 368.6 559.1 l
+ 367.9 559.1 l
+ 367.9 560.6 l
+ 368.6 560.6 l
+ h
+ eofill
+ n
+ 368.6 557.7 m
+ 368.6 556.2 l
+ 367.9 556.2 l
+ 367.9 557.7 l
+ 368.6 557.7 l
+ h
+ eofill
+ n
+ 368.6 554.8 m
+ 368.6 553.3 l
+ 367.9 553.3 l
+ 367.9 554.8 l
+ 368.6 554.8 l
+ h
+ eofill
+ n
+ 368.6 551.9 m
+ 368.6 550.4 l
+ 367.9 550.4 l
+ 367.9 551.9 l
+ 368.6 551.9 l
+ h
+ eofill
+ n
+ 368.6 549 m
+ 368.6 547.5 l
+ 367.9 547.5 l
+ 367.9 549 l
+ 368.6 549 l
+ h
+ eofill
+ n
+ 368.6 546.1 m
+ 368.6 544.6 l
+ 367.9 544.6 l
+ 367.9 546.1 l
+ 368.6 546.1 l
+ h
+ eofill
+ n
+ 368.6 543.2 m
+ 368.6 541.8 l
+ 367.9 541.8 l
+ 367.9 543.2 l
+ 368.6 543.2 l
+ h
+ eofill
+ n
+ 368.6 540.3 m
+ 368.6 538.9 l
+ 367.9 538.9 l
+ 367.9 540.3 l
+ 368.6 540.3 l
+ h
+ eofill
+ n
+ 368.6 537.4 m
+ 368.6 536 l
+ 367.9 536 l
+ 367.9 537.4 l
+ 368.6 537.4 l
+ h
+ eofill
+ n
+ 162.9 659.1 m
+ 368.6 659.1 l
+ 368.6 658.4 l
+ 162.9 658.4 l
+ 162.9 659.1 l
+ h
+ eofill
+ q
+ 231.4 669.7 m
+ /N8 12 Tf
+ (S) show
+ 238.1 669.7 m
+ (te) show
+ 246.8 669.7 m
+ (a) show
+ 252 669.7 m
+ (dy S) show
+ 273.8 669.7 m
+ (ta) show
+ 282.4 669.7 m
+ (te) show
+ Q
+ q
+ 118.3 634.4 m
+ /N8 12 Tf
+ (R) show
+ 126.4 634.4 m
+ (a) show
+ 131.6 634.4 m
+ (mp ) show
+ Q
+ q
+ 118.3 619.7 m
+ /N8 12 Tf
+ (Up) show
+ Q
+ q
+ 393.8 634.4 m
+ /N8 12 Tf
+ (R) show
+ 401.8 634.4 m
+ (a) show
+ 407.1 634.4 m
+ (mp ) show
+ Q
+ q
+ 393.8 619.7 m
+ /N8 12 Tf
+ (Down) show
+ Q
+ q
+ 101.8 559.9 m
+ /N8 [0.0767059 10.9985 -10.9985 0.0767059 0 0] Tf
+ (Num) show
+ 101.9 582 m
+ (be) show
+ 101.9 592.4 m
+ (r) show
+ 102 596.1 m
+ ( of) show
+ 102 608.1 m
+ ( ove) show
+ 102.2 626.8 m
+ (r) show
+ 102.2 630.5 m
+ (l) show
+ 102.2 633.7 m
+ (a) show
+ 102.3 638.6 m
+ (ppe) show
+ 102.4 654.5 m
+ (d i) show
+ 102.5 665.9 m
+ (t) show
+ 102.5 669.1 m
+ (e) show
+ 102.5 674 m
+ (r) show
+ 102.5 677.7 m
+ (a) show
+ 102.6 682.6 m
+ (t) show
+ 102.6 685.7 m
+ (i) show
+ 102.7 688.8 m
+ (ons) show
+ Q
+ q
+ 428.3 549.9 m
+ /N8 11 Tf
+ (Ti) show
+ 438.1 549.9 m
+ (m) show
+ 446.8 549.9 m
+ (e) show
+ Q
+ Q
+ PDFVars/TermAll get exec end end
+ userdict /pgsave get restore
+ showpage
+ %%PageTrailer
+ %%EndPage
+ %%Trailer
+ %%DocumentProcessColors: Cyan Magenta Yellow Black
+ %%DocumentSuppliedResources:
+ %%+ font BAAAAA+NimbusRomNo9L-Regu
+ %%+ procset (Adobe Acrobat - PDF operators) 1.2 0
+ %%+ procset (Adobe Acrobat - type operators) 1.2 0
+ %%EOF
+ 
+ %%EndDocument
+ 
+  endTexFig
+  2020 3152 a Fx(Figure)60 b(1.2:)80 b(P)-5 b(attern)59
+ b(of)i(Soft)-5 b(w)g(are)59 b(Pip)5 b(elined)59 b(Lo)5
+ b(op)282 3702 y(Figure)75 b(1.3\(a\))f(sho)-5 b(ws)75
+ b(the)g(iterations)e(and)j(instructions)d(selected)h(for)h(the)g(k)-5
+ b(ernel.)124 b(The)76 b(prologue)e(for)0 4067 y(our)68
+ b(simple)f(lo)5 b(op)67 b(is)h(comp)5 b(osed)67 b(of)g(all)g(the)h
+ (instructions)e(ab)5 b(o)-5 b(v)g(e)68 b(the)g(k)-5 b(ernel,)69
+ b(and)f(the)g(epilogue)e(are)i(all)f(the)0 4433 y(instructions)46
+ b(b)5 b(elo)-5 b(w)48 b(the)g(k)-5 b(ernel.)75 b(With)47
+ b(this)h(reconstructed)f(lo)5 b(op,)49 b(the)f(k)-5 b(ernel)47
+ b(\(Figure)h(1.3\(b\)\))e(no)-5 b(w)49 b(initiates)0
+ 4798 y(iterations)e(of)h(the)g(lo)5 b(op)48 b(in)g(three)g(cycles)f
+ (instead)h(of)g(the)g(original)f(lo)5 b(op's)47 b(four)i(cycles.)74
+ b(If)48 b(this)g(lo)5 b(op)48 b(has)g(a)h(large)0 5163
+ y(iteration)69 b(coun)-5 b(t,)72 b(the)e(ma)10 b(jorit)-5
+ b(y)69 b(of)i(the)f(time)f(w)-5 b(ould)70 b(b)5 b(e)71
+ b(sp)5 b(en)-5 b(t)70 b(executing)f(the)h(k)-5 b(ernel's)70
+ b(optimal)e(sc)-5 b(hedule)0 5529 y(and)61 b(sp)5 b(eeding)59
+ b(up)i(the)f(o)-5 b(v)g(erall)59 b(execution)g(time)g(of)h(the)h
+ (program)f(b)-5 b(y)60 b(1.3)g(times.)282 5894 y(Mo)5
+ b(dulo)70 b(Sc)-5 b(heduling)69 b(algorithms)g(traditionally)f(com)-5
+ b(bine)69 b(a)i(set)f(of)g(heuristics)f(and)h(list)f(sc)-5
+ b(heduling)69 b(to)0 6260 y(create)61 b(this)f(k)-5 b(ernel.)83
+ b(These)61 b(tec)-5 b(hniques)60 b(are)i(discussed)e(further)h(in)g
+ (Chapter)h(3.)83 b(List)60 b(sc)-5 b(heduling)60 b(and)h(other)0
+ 6625 y(sc)-5 b(heduling)59 b(terms)g(are)i(explained)e(in)h(Chapter)h
+ (2.)269 6992 y
+  18945146 8335860 5920358 38153420 29733355 48810065 startTexFig
+  269 6992 a
+ %%BeginDocument: figs/SoftwarePipelineLoop.ps
+ %!PS-Adobe-3.0
+ %%Title: (SoftwarePipelineLoop.pdf)
+ %%Version: 1 4
+ %%Creator: (\376\377)
+ %%CreationDate: (D:20050505155454-05'00')
+ %%DocumentData: Clean7Bit
+ %%LanguageLevel: 2
+ %%BoundingBox: 90 580 452 742
+ %%Pages: 1
+ %%DocumentProcessColors: (atend)
+ %%DocumentSuppliedResources: (atend)
+ %%EndComments
+ %%BeginDefaults
+ %%EndDefaults
+ %%BeginProlog
+ %%EndProlog
+ %%BeginSetup
+ %%BeginResource: l2check
+ %%Copyright: Copyright 1993 Adobe Systems Incorporated. All Rights Reserved.
+ systemdict /languagelevel known
+ { systemdict /languagelevel get 1 eq }
+ { true }
+ ifelse
+ {
+ initgraphics /Helvetica findfont 18 scalefont setfont
+ 72 600 moveto (Error: Your printer driver needs to be configured) dup show
+ 72 580 moveto (for printing to a PostScript Language Level 1 printer.) dup show
+ exch = =
+ /Helvetica-Bold findfont 16 scalefont setfont
+ 72 520 moveto (Windows and Unix) show
+ /Times-Roman findfont 16 scalefont setfont
+ 72 500 moveto (Select ?Language Level 1? in the PostScript options section) show
+ 72 480 moveto (of the Acrobat print dialog.) show
+ /Helvetica-Bold findfont 16 scalefont setfont
+ 72 440 moveto (Macintosh) show
+ /Times-Roman findfont 16 scalefont setfont
+ 72 420 moveto (In the Chooser, select your printer driver.) show
+ 72 400 moveto (Then select your printer and click the Setup button.) show
+ 72 380 moveto (Follow any on-screen dialogs that may appear.) show
+ showpage
+ quit
+ }
+ if
+ %%EndResource
+ userdict /pdf_svglb currentglobal put true setglobal
+ %%BeginResource: file Pscript_CFF PSVER
+ userdict/ct_CffDict 6 dict put ct_CffDict begin/F0Subr{systemdict/internaldict
+ known{1183615869 systemdict/internaldict get exec/FlxProc known{save true}{
+ false}ifelse}{userdict/internaldict known not{userdict/internaldict{count 0 eq
+ {/internaldict errordict/invalidaccess get exec}if dup type/integertype ne{
+ /internaldict errordict/invalidaccess get exec}if dup 1183615869 eq{pop 0}{
+ /internaldict errordict/invalidaccess get exec}ifelse}dup 14 get 1 25 dict put
+ bind executeonly put}if 1183615869 userdict/internaldict get exec/FlxProc
+ known{save true}{false}ifelse}ifelse[systemdict/internaldict known not{100
+ dict/begin cvx/mtx matrix/def cvx}if systemdict/currentpacking known{
+ currentpacking true setpacking}if{systemdict/internaldict known{1183615869
+ systemdict/internaldict get exec dup/$FlxDict known not{dup dup length exch
+ maxlength eq{pop userdict dup/$FlxDict known not{100 dict begin/mtx matrix def
+ dup/$FlxDict currentdict put end}if}{100 dict begin/mtx matrix def dup
+ /$FlxDict currentdict put end}ifelse}if/$FlxDict get begin}if grestore/exdef{
+ exch def}def/dmin exch abs 100 div def/epX exdef/epY exdef/c4y2 exdef/c4x2
+ exdef/c4y1 exdef/c4x1 exdef/c4y0 exdef/c4x0 exdef/c3y2 exdef/c3x2 exdef/c3y1
+ exdef/c3x1 exdef/c3y0 exdef/c3x0 exdef/c1y2 exdef/c1x2 exdef/c2x2 c4x2 def
+ /c2y2 c4y2 def/yflag c1y2 c3y2 sub abs c1x2 c3x2 sub abs gt def/PickCoords{{
+ c1x0 c1y0 c1x1 c1y1 c1x2 c1y2 c2x0 c2y0 c2x1 c2y1 c2x2 c2y2}{c3x0 c3y0 c3x1
+ c3y1 c3x2 c3y2 c4x0 c4y0 c4x1 c4y1 c4x2 c4y2}ifelse/y5 exdef/x5 exdef/y4 exdef
+ /x4 exdef/y3 exdef/x3 exdef/y2 exdef/x2 exdef/y1 exdef/x1 exdef/y0 exdef/x0
+ exdef}def mtx currentmatrix pop mtx 0 get abs 1e-05 lt mtx 3 get abs 1e-05 lt
+ or{/flipXY -1 def}{mtx 1 get abs 1e-05 lt mtx 2 get abs 1e-05 lt or{/flipXY 1
+ def}{/flipXY 0 def}ifelse}ifelse/erosion 1 def systemdict/internaldict known{
+ 1183615869 systemdict/internaldict get exec dup/erosion known{/erosion get
+ /erosion exch def}{pop}ifelse}if yflag{flipXY 0 eq c3y2 c4y2 eq or{false
+ PickCoords}{/shrink c3y2 c4y2 eq{0}{c1y2 c4y2 sub c3y2 c4y2 sub div abs}ifelse
+ def/yshrink{c4y2 sub shrink mul c4y2 add}def/c1y0 c3y0 yshrink def/c1y1 c3y1
+ yshrink def/c2y0 c4y0 yshrink def/c2y1 c4y1 yshrink def/c1x0 c3x0 def/c1x1
+ c3x1 def/c2x0 c4x0 def/c2x1 c4x1 def/dY 0 c3y2 c1y2 sub round dtransform
+ flipXY 1 eq{exch}if pop abs def dY dmin lt PickCoords y2 c1y2 sub abs .001 gt{
+ c1x2 c1y2 transform flipXY 1 eq{exch}if/cx exch def/cy exch def/dY 0 y2 c1y2
+ sub round dtransform flipXY 1 eq{exch}if pop def dY round dup 0 ne{/dY exdef}{
+ pop dY 0 lt{-1}{1}ifelse/dY exdef}ifelse/erode PaintType 2 ne erosion .5 ge
+ and def erode{/cy cy .5 sub def}if/ey cy dY add def/ey ey ceiling ey sub ey
+ floor add def erode{/ey ey .5 add def}if ey cx flipXY 1 eq{exch}if itransform
+ exch pop y2 sub/eShift exch def/y1 y1 eShift add def/y2 y2 eShift add def/y3
+ y3 eShift add def}if}ifelse}{flipXY 0 eq c3x2 c4x2 eq or{false PickCoords}{
+ /shrink c3x2 c4x2 eq{0}{c1x2 c4x2 sub c3x2 c4x2 sub div abs}ifelse def/xshrink
+ {c4x2 sub shrink mul c4x2 add}def/c1x0 c3x0 xshrink def/c1x1 c3x1 xshrink def
+ /c2x0 c4x0 xshrink def/c2x1 c4x1 xshrink def/c1y0 c3y0 def/c1y1 c3y1 def/c2y0
+ c4y0 def/c2y1 c4y1 def/dX c3x2 c1x2 sub round 0 dtransform flipXY -1 eq{exch}
+ if pop abs def dX dmin lt PickCoords x2 c1x2 sub abs .001 gt{c1x2 c1y2
+ transform flipXY -1 eq{exch}if/cy exch def/cx exch def/dX x2 c1x2 sub round 0
+ dtransform flipXY -1 eq{exch}if pop def dX round dup 0 ne{/dX exdef}{pop dX 0
+ lt{-1}{1}ifelse/dX exdef}ifelse/erode PaintType 2 ne erosion .5 ge and def
+ erode{/cx cx .5 sub def}if/ex cx dX add def/ex ex ceiling ex sub ex floor add
+ def erode{/ex ex .5 add def}if ex cy flipXY -1 eq{exch}if itransform pop x2
+ sub/eShift exch def/x1 x1 eShift add def/x2 x2 eShift add def/x3 x3 eShift add
+ def}if}ifelse}ifelse x2 x5 eq y2 y5 eq or{x5 y5 lineto}{x0 y0 x1 y1 x2 y2
+ curveto x3 y3 x4 y4 x5 y5 curveto}ifelse epY epX}systemdict/currentpacking
+ known{exch setpacking}if/exec cvx/end cvx]cvx executeonly exch{pop true exch
+ restore}{systemdict/internaldict known not{1183615869 userdict/internaldict
+ get exec exch/FlxProc exch put true}{1183615869 systemdict/internaldict get
+ exec dup length exch maxlength eq{false}{1183615869 systemdict/internaldict
+ get exec exch/FlxProc exch put true}ifelse}ifelse}ifelse{systemdict
+ /internaldict known{1183615869 systemdict/internaldict get exec/FlxProc get
+ exec}{1183615869 userdict/internaldict get exec/FlxProc get exec}ifelse}if}
+ executeonly def/F1Subr{gsave currentpoint newpath moveto}bind def/F2Subr{
+ currentpoint grestore gsave currentpoint newpath moveto}bind def/HSSubr{
+ systemdict/internaldict known not{pop 3}{1183615869 systemdict/internaldict
+ get exec dup/startlock known{/startlock get exec}{dup/strtlck known{/strtlck
+ get exec}{pop 3}ifelse}ifelse}ifelse}bind def end
+ %%EndResource
+ 
+ userdict /pdf_svglb get setglobal
+ /currentpacking where{pop currentpacking true setpacking}if
+ %%BeginResource: procset pdfvars
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Version: 5.0 6
+ %%Title: definition of dictionary of variables used by PDF & PDFText procsets
+ userdict /PDF 160 dict put
+ userdict /PDFVars 89 dict dup begin put
+ /docSetupDone false def
+ /InitAll 0 def
+ /TermAll 0 def
+ /DocInitAll 0 def
+ /DocTermAll 0 def
+ /_pdfEncodings 2 array def
+ /_pdf_str1 1 string def
+ /_pdf_i 0 def
+ /_pdf_na 0 def
+ /_pdf_showproc 0 def
+ /_italMtx [1 0 .212557 1 0 0] def
+ /_italMtx_WMode1 [1 -.212557 0 1 0 0] def
+ /_italMtxType0 [1 0 .1062785 1 0 0] def
+ /_italMtx_WMode1Type0 [1 -.1062785 0 1 0 0] def
+ /_basefont 0 def
+ /_basefonto 0 def
+ /_pdf_oldCIDInit null def
+ /_pdf_FontDirectory 30 dict def
+ /_categories 10 dict def
+ /_sa? true def
+ /_ColorSep5044? false def
+ /nulldict 0 dict def
+ /_processColors 0 def
+ /overprintstack null def
+ /_defaulttransfer currenttransfer def
+ /_defaultflatness currentflat def
+ /_defaulthalftone null def
+ /_defaultcolortransfer null def
+ /_defaultblackgeneration null def
+ /_defaultundercolorremoval null def
+ /_defaultcolortransfer null def
+ PDF begin
+ [/c/cs/cm/d/d0/f/h/i/j/J/l/m/M/n/q/Q/re/ri/S/sc/sh/Tf/w/W
+ /applyInterpFunc/applystitchFunc/domainClip/encodeInput
+ /initgs/int/limit/rangeClip
+ /defineRes/findRes/setSA/pl
+ %% to keep CoolType entries in GlyphDirProcs safe from collisions with Win PS driver
+ /? /! /| /: /+ /GetGlyphDirectory
+ /pdf_flushFilters /pdf_readstring /pdf_dictOp /pdf_image /pdf_maskedImage
+ /pdf_shfill /pdf_sethalftone
+ ] {null def} bind forall
+ end
+ end
+ %%EndResource
+ PDFVars begin PDF begin
+ %%BeginResource: procset pdfutil
+ %%Copyright: Copyright 1993-1999 Adobe Systems Incorporated. All Rights Reserved.
+ %%Version: 4.0 2
+ %%Title: Basic utilities used by other PDF procsets
+ /bd {bind def} bind def
+ /ld {load def} bd
+ /bld {
+ dup length dict begin
+ { null def } forall
+ bind
+ end
+ def
+ } bd
+ /dd { PDFVars 3 1 roll put } bd
+ /xdd { exch dd } bd
+ /Level2?
+ systemdict /languagelevel known
+ { systemdict /languagelevel get 2 ge } { false } ifelse
+ def
+ /Level1? Level2? not def
+ /Level3?
+ systemdict /languagelevel known
+ {systemdict /languagelevel get 3 eq } { false } ifelse
+ def
+ /getifknown {
+ 2 copy known { get true } { pop pop false } ifelse
+ } bd
+ /here {
+ currentdict exch getifknown
+ } bd
+ /isdefined? { where { pop true } { false } ifelse } bd
+ %%EndResource
+ %%BeginResource: procset pdf
+ %%Version: 5.0 7
+ %%Copyright: Copyright 1998-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Title: General operators for PDF, common to all Language Levels.
+ /cm { matrix astore concat } bd
+ /d /setdash ld
+ /f /fill ld
+ /h /closepath ld
+ /i {dup 0 eq {pop _defaultflatness} if setflat} bd
+ /j /setlinejoin ld
+ /J /setlinecap ld
+ /M /setmiterlimit ld
+ /n /newpath ld
+ /S /stroke ld
+ /w /setlinewidth ld
+ /W /clip ld
+ /initgs {
+ 0 setgray
+ [] 0 d
+ 0 j
+ 0 J
+ 10 M
+ 1 w
+ false setSA
+ /_defaulttransfer load settransfer
+ 0 i
+ /RelativeColorimetric ri
+ newpath
+ } bd
+ /int {
+ dup 2 index sub 3 index 5 index sub div 6 -2 roll sub mul
+ exch pop add exch pop
+ } bd
+ /limit {
+ dup 2 index le { exch } if pop
+ dup 2 index ge { exch } if pop
+ } bd
+ /domainClip {
+ Domain aload pop 3 2 roll
+ limit
+ } [/Domain] bld
+ /applyInterpFunc {
+ 0 1 DimOut 1 sub
+ {
+ dup C0 exch get exch
+ dup C1 exch get exch
+ 3 1 roll
+ 1 index sub
+ 3 index
+ N exp mul add
+ exch
+ currentdict /Range_lo known
+ {
+ dup Range_lo exch get exch
+ Range_hi exch get
+ 3 2 roll limit
+ }
+ {
+ pop
+ }
+ ifelse
+ exch
+ } for
+ pop
+ } [/DimOut /C0 /C1 /N /Range_lo /Range_hi] bld
+ /encodeInput {
+ NumParts 1 sub
+ 0 1 2 index
+ {
+ dup Bounds exch get
+ 2 index gt
+ { exit }
+ { dup
+ 3 index eq
+ { exit }
+ { pop } ifelse
+ } ifelse
+ } for
+ 3 2 roll pop
+ dup Bounds exch get exch
+ dup 1 add Bounds exch get exch
+ 2 mul
+ dup Encode exch get exch
+ 1 add Encode exch get
+ int
+ } [/NumParts /Bounds /Encode] bld
+ /rangeClip {
+ exch dup Range_lo exch get
+ exch Range_hi exch get
+ 3 2 roll
+ limit
+ } [/Range_lo /Range_hi] bld
+ /applyStitchFunc {
+ Functions exch get exec
+ currentdict /Range_lo known {
+ 0 1 DimOut 1 sub {
+ DimOut 1 add -1 roll
+ rangeClip
+ } for
+ } if
+ } [/Functions /Range_lo /DimOut] bld
+ /pdf_flushfilters
+ {
+ aload length
+ { dup status
+ 1 index currentfile ne and
+ { dup flushfile closefile }
+ { pop }
+ ifelse
+ } repeat
+ } bd
+ /pdf_readstring
+ {
+ 1 index dup length 1 sub get
+ exch readstring pop
+ exch pdf_flushfilters
+ } bind def
+ /pdf_dictOp
+ {
+ 3 2 roll
+ 10 dict copy
+ begin
+ _Filters dup length 1 sub get def
+ currentdict exch exec
+ _Filters pdf_flushfilters
+ end
+ } [/_Filters] bld
+ /pdf_image {{image} /DataSource pdf_dictOp} bd
+ /pdf_imagemask {{imagemask} /DataSource pdf_dictOp} bd
+ /pdf_shfill {{sh} /DataSource pdf_dictOp} bd
+ /pdf_sethalftone {{sethalftone} /Thresholds pdf_dictOp} bd
+ /pdf_maskedImage
+ {
+ 10 dict copy begin
+ /miDict currentdict def
+ /DataDict DataDict 10 dict copy def
+ DataDict begin
+ /DataSource
+ _Filters dup length 1 sub get
+ def
+ miDict image
+ _Filters pdf_flushfilters
+ end
+ end
+ } [/miDict /DataDict /_Filters] bld
+ /RadialShade {
+ 40 dict begin
+ /background exch def
+ /ext1 exch def
+ /ext0 exch def
+ /BBox exch def
+ /r2 exch def
+ /c2y exch def
+ /c2x exch def
+ /r1 exch def
+ /c1y exch def
+ /c1x exch def
+ /rampdict exch def
+ gsave
+ BBox length 0 gt {
+ newpath
+ BBox 0 get BBox 1 get moveto
+ BBox 2 get BBox 0 get sub 0 rlineto
+ 0 BBox 3 get BBox 1 get sub rlineto
+ BBox 2 get BBox 0 get sub neg 0 rlineto
+ closepath
+ clip
+ newpath
+ } if
+ c1x c2x eq
+ {
+ c1y c2y lt {/theta 90 def}{/theta 270 def} ifelse
+ }
+ {
+ /slope c2y c1y sub c2x c1x sub div def
+ /theta slope 1 atan def
+ c2x c1x lt c2y c1y ge and { /theta theta 180 sub def} if
+ c2x c1x lt c2y c1y lt and { /theta theta 180 add def} if
+ }
+ ifelse
+ gsave
+ clippath
+ c1x c1y translate
+ theta rotate
+ -90 rotate
+ { pathbbox } stopped
+ { 0 0 0 0 } if
+ /yMax exch def
+ /xMax exch def
+ /yMin exch def
+ /xMin exch def
+ grestore
+ xMax xMin eq yMax yMin eq or
+ {
+ grestore
+ end
+ }
+ {
+ rampdict begin
+ 40 dict begin
+ background length 0 gt { background sssetbackground gsave clippath fill grestore } if
+ gsave
+ c1x c1y translate
+ theta rotate
+ -90 rotate
+ /c2y c1x c2x sub dup mul c1y c2y sub dup mul add sqrt def
+ /c1y 0 def
+ /c1x 0 def
+ /c2x 0 def
+ ext0 {
+ 0 getrampcolor
+ c2y r2 add r1 lt
+ {
+ c1x c1y r1 360 0 arcn
+ xMin yMin moveto
+ xMax yMin lineto
+ xMax yMax lineto
+ xMin yMax lineto
+ xMin yMin lineto
+ eofill
+ }
+ {
+ c2y r1 add r2 le
+ {
+ c1x c1y r1 0 360 arc
+ fill
+ }
+ {
+ c2x c2y r2 0 360 arc fill
+ r1 r2 eq
+ {
+ /p1x r1 neg def
+ /p1y c1y def
+ /p2x r1 def
+ /p2y c1y def
+ p1x p1y moveto p2x p2y lineto p2x yMin lineto p1x yMin lineto
+ fill
+ }
+ {
+ /AA r2 r1 sub c2y div def
+ /theta AA 1 AA dup mul sub sqrt div 1 atan def
+ /SS1 90 theta add dup sin exch cos div def
+ /p1x r1 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def
+ /p1y p1x SS1 div neg def
+ /SS2 90 theta sub dup sin exch cos div def
+ /p2x r1 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def
+ /p2y p2x SS2 div neg def
+ r1 r2 gt
+ {
+ /L1maxX p1x yMin p1y sub SS1 div add def
+ /L2maxX p2x yMin p2y sub SS2 div add def
+ }
+ {
+ /L1maxX 0 def
+ /L2maxX 0 def
+ }ifelse
+ p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto
+ L1maxX L1maxX p1x sub SS1 mul p1y add lineto
+ fill
+ }
+ ifelse
+ }
+ ifelse
+ } ifelse
+ } if
+ c1x c2x sub dup mul
+ c1y c2y sub dup mul
+ add 0.5 exp
+ 0 dtransform
+ dup mul exch dup mul add 0.5 exp 72 div
+ 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 1 index 1 index lt { exch } if pop
+ /hires exch def
+ hires mul
+ /numpix exch def
+ /numsteps NumSamples def
+ /rampIndxInc 1 def
+ /subsampling false def
+ numpix 0 ne
+ {
+ NumSamples numpix div 0.5 gt
+ {
+ /numsteps numpix 2 div round cvi dup 1 le { pop 2 } if def
+ /rampIndxInc NumSamples 1 sub numsteps div def
+ /subsampling true def
+ } if
+ } if
+ /xInc c2x c1x sub numsteps div def
+ /yInc c2y c1y sub numsteps div def
+ /rInc r2 r1 sub numsteps div def
+ /cx c1x def
+ /cy c1y def
+ /radius r1 def
+ newpath
+ xInc 0 eq yInc 0 eq rInc 0 eq and and
+ {
+ 0 getrampcolor
+ cx cy radius 0 360 arc
+ stroke
+ NumSamples 1 sub getrampcolor
+ cx cy radius 72 hires div add 0 360 arc
+ 0 setlinewidth
+ stroke
+ }
+ {
+ 0
+ numsteps
+ {
+ dup
+ subsampling { round cvi } if
+ getrampcolor
+ cx cy radius 0 360 arc
+ /cx cx xInc add def
+ /cy cy yInc add def
+ /radius radius rInc add def
+ cx cy radius 360 0 arcn
+ eofill
+ rampIndxInc add
+ }
+ repeat
+ pop
+ } ifelse
+ ext1 {
+ c2y r2 add r1 lt
+ {
+ c2x c2y r2 0 360 arc
+ fill
+ }
+ {
+ c2y r1 add r2 le
+ {
+ c2x c2y r2 360 0 arcn
+ xMin yMin moveto
+ xMax yMin lineto
+ xMax yMax lineto
+ xMin yMax lineto
+ xMin yMin lineto
+ eofill
+ }
+ {
+ c2x c2y r2 0 360 arc fill
+ r1 r2 eq
+ {
+ /p1x r2 neg def
+ /p1y c2y def
+ /p2x r2 def
+ /p2y c2y def
+ p1x p1y moveto p2x p2y lineto p2x yMax lineto p1x yMax lineto
+ fill
+ }
+ {
+ /AA r2 r1 sub c2y div def
+ /theta AA 1 AA dup mul sub sqrt div 1 atan def
+ /SS1 90 theta add dup sin exch cos div def
+ /p1x r2 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def
+ /p1y c2y p1x SS1 div sub def
+ /SS2 90 theta sub dup sin exch cos div def
+ /p2x r2 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def
+ /p2y c2y p2x SS2 div sub def
+ r1 r2 lt
+ {
+ /L1maxX p1x yMax p1y sub SS1 div add def
+ /L2maxX p2x yMax p2y sub SS2 div add def
+ }
+ {
+ /L1maxX 0 def
+ /L2maxX 0 def
+ }ifelse
+ p1x p1y moveto p2x p2y lineto L2maxX L2maxX p2x sub SS2 mul p2y add lineto
+ L1maxX L1maxX p1x sub SS1 mul p1y add lineto
+ fill
+ }
+ ifelse
+ }
+ ifelse
+ } ifelse
+ } if
+ grestore
+ grestore
+ end
+ end
+ end
+ } ifelse
+ } bd
+ /GenStrips {
+ 40 dict begin
+ /background exch def
+ /ext1 exch def
+ /ext0 exch def
+ /BBox exch def
+ /y2 exch def
+ /x2 exch def
+ /y1 exch def
+ /x1 exch def
+ /rampdict exch def
+ gsave
+ BBox length 0 gt {
+ newpath
+ BBox 0 get BBox 1 get moveto
+ BBox 2 get BBox 0 get sub 0 rlineto
+ 0 BBox 3 get BBox 1 get sub rlineto
+ BBox 2 get BBox 0 get sub neg 0 rlineto
+ closepath
+ clip
+ newpath
+ } if
+ x1 x2 eq
+ {
+ y1 y2 lt {/theta 90 def}{/theta 270 def} ifelse
+ }
+ {
+ /slope y2 y1 sub x2 x1 sub div def
+ /theta slope 1 atan def
+ x2 x1 lt y2 y1 ge and { /theta theta 180 sub def} if
+ x2 x1 lt y2 y1 lt and { /theta theta 180 add def} if
+ }
+ ifelse
+ gsave
+ clippath
+ x1 y1 translate
+ theta rotate
+ { pathbbox } stopped
+ { 0 0 0 0 } if
+ /yMax exch def
+ /xMax exch def
+ /yMin exch def
+ /xMin exch def
+ grestore
+ xMax xMin eq yMax yMin eq or
+ {
+ grestore
+ end
+ }
+ {
+ rampdict begin
+ 20 dict begin
+ background length 0 gt { background sssetbackground gsave clippath fill grestore } if
+ gsave
+ x1 y1 translate
+ theta rotate
+ /xStart 0 def
+ /xEnd x2 x1 sub dup mul y2 y1 sub dup mul add 0.5 exp def
+ /ySpan yMax yMin sub def
+ /numsteps NumSamples def
+ /rampIndxInc 1 def
+ /subsampling false def
+ xStart 0 transform
+ xEnd 0 transform
+ 3 -1 roll
+ sub dup mul
+ 3 1 roll
+ sub dup mul
+ add 0.5 exp 72 div
+ 0 72 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt
+ 1 index 1 index lt { exch } if pop
+ mul
+ /numpix exch def
+ numpix 0 ne
+ {
+ NumSamples numpix div 0.5 gt
+ {
+ /numsteps numpix 2 div round cvi dup 1 le { pop 2 } if def
+ /rampIndxInc NumSamples 1 sub numsteps div def
+ /subsampling true def
+ } if
+ } if
+ ext0 {
+ 0 getrampcolor
+ xMin xStart lt
+ { xMin yMin xMin neg ySpan rectfill } if
+ } if
+ /xInc xEnd xStart sub numsteps div def
+ /x xStart def
+ 0
+ numsteps
+ {
+ dup
+ subsampling { round cvi } if
+ getrampcolor
+ x yMin xInc ySpan rectfill
+ /x x xInc add def
+ rampIndxInc add
+ }
+ repeat
+ pop
+ ext1 {
+ xMax xEnd gt
+ { xEnd yMin xMax xEnd sub ySpan rectfill } if
+ } if
+ grestore
+ grestore
+ end
+ end
+ end
+ } ifelse
+ } bd
+ %%EndResource
+ %%BeginResource: procset pdflev2
+ %%Version: 5.0 15
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%LanguageLevel: 2
+ %%Title: PDF operators, with code specific for Level 2
+ /docinitialize {
+ PDF begin
+ /_defaulthalftone currenthalftone dd
+ /_defaultblackgeneration currentblackgeneration dd
+ /_defaultundercolorremoval currentundercolorremoval dd
+ /_defaultcolortransfer [currentcolortransfer] dd
+ /_defaulttransfer currenttransfer dd
+ end
+ PDFVars /docSetupDone true put
+ } bd
+ /initialize {
+ PDFVars /docSetupDone get {
+ _defaulthalftone sethalftone
+ /_defaultblackgeneration load setblackgeneration
+ /_defaultundercolorremoval load setundercolorremoval
+ _defaultcolortransfer aload pop setcolortransfer
+ } if
+ false setoverprint
+ } bd
+ /terminate { } bd
+ /c /curveto ld
+ /cs /setcolorspace ld
+ /l /lineto ld
+ /m /moveto ld
+ /q /gsave ld
+ /Q /grestore ld
+ /sc /setcolor ld
+ /setSA/setstrokeadjust ld
+ /re {
+ 4 2 roll m
+ 1 index 0 rlineto
+ 0 exch rlineto
+ neg 0 rlineto
+ h
+ } bd
+ /concattransferfuncs {
+ [ 3 1 roll /exec load exch /exec load ] cvx
+ } bd
+ /concatandsettransfer {
+ /_defaulttransfer load concattransferfuncs settransfer
+ } bd
+ /concatandsetcolortransfer {
+ _defaultcolortransfer aload pop
+ 8 -1 roll 5 -1 roll concattransferfuncs 7 1 roll
+ 6 -1 roll 4 -1 roll concattransferfuncs 5 1 roll
+ 4 -1 roll 3 -1 roll concattransferfuncs 3 1 roll
+ concattransferfuncs
+ setcolortransfer
+ } bd
+ /defineRes/defineresource ld
+ /findRes/findresource ld
+ currentglobal
+ true systemdict /setglobal get exec
+ [/Function /ExtGState /Form /Shading /FunctionDictionary /MadePattern /PatternPrototype /DataSource /Image]
+ { /Generic /Category findresource dup length dict copy /Category defineresource pop }
+ forall
+ systemdict /setglobal get exec
+ /ri
+ {
+ /findcolorrendering isdefined?
+ {
+ mark exch
+ findcolorrendering
+ counttomark 2 eq
+ { type /booleantype eq
+ { dup type /nametype eq
+ { dup /ColorRendering resourcestatus
+ { pop pop
+ dup /DefaultColorRendering ne
+ {
+ /ColorRendering findresource
+ setcolorrendering
+ } if
+ } if
+ } if
+ } if
+ } if
+ cleartomark
+ }
+ { pop
+ } ifelse
+ } bd
+ /knownColorants? {
+ pop false
+ } bd
+ /getrampcolor {
+ /indx exch def
+ 0 1 NumComp 1 sub {
+ dup
+ Samples exch get
+ dup type /stringtype eq { indx get } if
+ exch
+ Scaling exch get aload pop
+ 3 1 roll
+ mul add
+ } for
+ setcolor
+ } bd
+ /sssetbackground { aload pop setcolor } bd
+ %%EndResource
+ %%BeginResource: procset pdftext
+ %%Version: 5.0 6
+ %%Copyright: Copyright 1987-2001 Adobe Systems Incorporated. All Rights Reserved.
+ %%Title: Text operators for PDF
+ PDF /PDFText 78 dict dup begin put
+ /docinitialize
+ {
+ /resourcestatus where {
+ pop
+ /CIDParams /ProcSet resourcestatus {
+ pop pop
+ false /CIDParams /ProcSet findresource /SetBuildCompatible get exec
+ } if
+ } if
+ PDF begin
+ PDFText /_pdfDefineIdentity-H known
+ { PDFText /_pdfDefineIdentity-H get exec}
+ if
+ end
+ } bd
+ /initialize {
+ PDFText begin
+ } bd
+ /terminate { end } bd
+ Level2?
+ {
+ /_safeput
+ {
+ 3 -1 roll load 3 1 roll put
+ }
+ bd
+ }
+ {
+ /_safeput
+ {
+ 2 index load dup dup length exch maxlength ge
+ { dup length 5 add dict copy
+ 3 index xdd
+ }
+ { pop }
+ ifelse
+ 3 -1 roll load 3 1 roll put
+ }
+ bd
+ }
+ ifelse
+ /pdf_has_composefont? systemdict /composefont known def
+ /CopyFont {
+ {
+ 1 index /FID ne 2 index /UniqueID ne and
+ { def } { pop pop } ifelse
+ } forall
+ } bd
+ /Type0CopyFont
+ {
+ exch
+ dup length dict
+ begin
+ CopyFont
+ [
+ exch
+ FDepVector
+ {
+ dup /FontType get 0 eq
+ {
+ 1 index Type0CopyFont
+ /_pdfType0 exch definefont
+ }
+ {
+ /_pdfBaseFont exch
+ 2 index exec
+ }
+ ifelse
+ exch
+ }
+ forall
+ pop
+ ]
+ /FDepVector exch def
+ currentdict
+ end
+ } bd
+ Level2? {currentglobal true setglobal} if
+ /cHexEncoding
+ [/c00/c01/c02/c03/c04/c05/c06/c07/c08/c09/c0A/c0B/c0C/c0D/c0E/c0F/c10/c11/c12
+ /c13/c14/c15/c16/c17/c18/c19/c1A/c1B/c1C/c1D/c1E/c1F/c20/c21/c22/c23/c24/c25
+ /c26/c27/c28/c29/c2A/c2B/c2C/c2D/c2E/c2F/c30/c31/c32/c33/c34/c35/c36/c37/c38
+ /c39/c3A/c3B/c3C/c3D/c3E/c3F/c40/c41/c42/c43/c44/c45/c46/c47/c48/c49/c4A/c4B
+ /c4C/c4D/c4E/c4F/c50/c51/c52/c53/c54/c55/c56/c57/c58/c59/c5A/c5B/c5C/c5D/c5E
+ /c5F/c60/c61/c62/c63/c64/c65/c66/c67/c68/c69/c6A/c6B/c6C/c6D/c6E/c6F/c70/c71
+ /c72/c73/c74/c75/c76/c77/c78/c79/c7A/c7B/c7C/c7D/c7E/c7F/c80/c81/c82/c83/c84
+ /c85/c86/c87/c88/c89/c8A/c8B/c8C/c8D/c8E/c8F/c90/c91/c92/c93/c94/c95/c96/c97
+ /c98/c99/c9A/c9B/c9C/c9D/c9E/c9F/cA0/cA1/cA2/cA3/cA4/cA5/cA6/cA7/cA8/cA9/cAA
+ /cAB/cAC/cAD/cAE/cAF/cB0/cB1/cB2/cB3/cB4/cB5/cB6/cB7/cB8/cB9/cBA/cBB/cBC/cBD
+ /cBE/cBF/cC0/cC1/cC2/cC3/cC4/cC5/cC6/cC7/cC8/cC9/cCA/cCB/cCC/cCD/cCE/cCF/cD0
+ /cD1/cD2/cD3/cD4/cD5/cD6/cD7/cD8/cD9/cDA/cDB/cDC/cDD/cDE/cDF/cE0/cE1/cE2/cE3
+ /cE4/cE5/cE6/cE7/cE8/cE9/cEA/cEB/cEC/cED/cEE/cEF/cF0/cF1/cF2/cF3/cF4/cF5/cF6
+ /cF7/cF8/cF9/cFA/cFB/cFC/cFD/cFE/cFF] def
+ Level2? {setglobal} if
+ /modEnc {
+ /_enc xdd
+ /_icode 0 dd
+ counttomark 1 sub -1 0
+ {
+ index
+ dup type /nametype eq
+ {
+ _enc _icode 3 -1 roll put
+ _icode 1 add
+ }
+ if
+ /_icode xdd
+ } for
+ cleartomark
+ _enc
+ } bd
+ /trEnc {
+ /_enc xdd
+ 255 -1 0 {
+ exch dup -1 eq
+ { pop /.notdef }
+ { Encoding exch get }
+ ifelse
+ _enc 3 1 roll put
+ } for
+ pop
+ _enc
+ } bd
+ /TE {
+ /_i xdd
+ StandardEncoding 256 array copy modEnc
+ _pdfEncodings exch _i exch put
+ } bd
+ /TZ
+ {
+ /_usePDFEncoding xdd
+ findfont
+ dup length 6 add dict
+ begin
+ {
+ 1 index /FID ne { def } { pop pop } ifelse
+ } forall
+ /pdf_origFontName FontName def
+ /FontName exch def
+ currentdict /PaintType known
+ { PaintType 2 eq {/PaintType 0 def} if }
+ if
+ _usePDFEncoding 0 ge
+ {
+ /Encoding _pdfEncodings _usePDFEncoding get def
+ pop
+ }
+ {
+ _usePDFEncoding -1 eq
+ {
+ counttomark 0 eq
+ { pop }
+ {
+ Encoding 256 array copy
+ modEnc /Encoding exch def
+ }
+ ifelse
+ }
+ {
+ 256 array
+ trEnc /Encoding exch def
+ }
+ ifelse
+ }
+ ifelse
+ pdf_EuroProcSet pdf_origFontName known
+ {
+ pdf_origFontName pdf_AddEuroGlyphProc
+ } if
+ Level2?
+ {
+ currentdict /pdf_origFontName undef
+ } if
+ FontName currentdict
+ end
+ definefont pop
+ }
+ bd
+ Level2?
+ {
+ /TZG
+ {
+ currentglobal true setglobal
+ 2 index _pdfFontStatus
+ {
+ 2 index findfont
+ false setglobal
+ 3 index findfont
+ true setglobal
+ ne
+ {
+ 2 index findfont dup rcheck
+ {
+ dup length dict begin
+ {
+ 1 index /FID ne { def } { pop pop } ifelse
+ } forall
+ currentdict end
+ }
+ if
+ 3 index exch definefont pop
+ }
+ if
+ } if
+ setglobal
+ TZ
+ } bd
+ }
+ {
+ /TZG {TZ} bd
+ } ifelse
+ Level2?
+ {
+ currentglobal false setglobal
+ userdict /pdftext_data 5 dict put
+ pdftext_data
+ begin
+ /saveStacks
+ {
+ pdftext_data
+ begin
+ /vmmode currentglobal def
+ false setglobal
+ count array astore /os exch def
+ end
+ countdictstack array dictstack pdftext_data exch /ds exch put
+ cleardictstack pdftext_data /dscount countdictstack put
+ pdftext_data /vmmode get setglobal
+ } bind def
+ /restoreStacks
+ {
+ pdftext_data /vmmode currentglobal put false setglobal
+ clear cleardictstack
+ pdftext_data /ds get dup
+ pdftext_data /dscount get 1 2 index length 1 sub
+ { get begin dup } for
+ pop pop
+ pdftext_data /os get aload pop
+ pdftext_data /vmmode get setglobal
+ } bind def
+ /testForClonePrinterBug
+ {
+ currentglobal true setglobal
+ /undefinedCategory /Generic /Category findresource
+ dup length dict copy /Category defineresource pop
+ setglobal
+ pdftext_data /saveStacks get exec
+ pdftext_data /vmmode currentglobal put false setglobal
+ /undefined /undefinedCategory { resourcestatus } stopped
+ pdftext_data exch /bugFound exch put
+ pdftext_data /vmmode get setglobal
+ pdftext_data /restoreStacks get exec
+ pdftext_data /bugFound get
+ } bind def
+ end
+ setglobal
+ /pdf_resourcestatus
+ pdftext_data /testForClonePrinterBug get exec
+ {
+ {
+ pdftext_data /saveStacks get exec
+ pdftext_data /os get dup dup length 1 sub
+ dup 1 sub dup 0 lt { pop 0 } if
+ exch 1 exch { get exch dup } for
+ pop pop
+ { resourcestatus }
+ stopped
+ {
+ clear cleardictstack pdftext_data /restoreStacks get exec
+ { pop pop } stopped pop false
+ }
+ {
+ count array astore pdftext_data exch /results exch put
+ pdftext_data /restoreStacks get exec pop pop
+ pdftext_data /results get aload pop
+ }
+ ifelse
+ }
+ }
+ { { resourcestatus } }
+ ifelse
+ bd
+ }
+ if
+ Level2?
+ {
+ /_pdfUndefineResource
+ {
+ currentglobal 3 1 roll
+ _pdf_FontDirectory 2 index 2 copy known
+ {undef}
+ {pop pop}
+ ifelse
+ 1 index (pdf) exch _pdfConcatNames 1 index
+ 1 index 1 _pdfConcatNames 1 index
+ 5 index 1 _pdfConcatNames 1 index
+ 4
+ {
+ 2 copy pdf_resourcestatus
+ {
+ pop 2 lt
+ {2 copy findresource gcheck setglobal undefineresource}
+ {pop pop}
+ ifelse
+ }
+ { pop pop}
+ ifelse
+ } repeat
+ setglobal
+ } bd
+ }
+ {
+ /_pdfUndefineResource { pop pop} bd
+ }
+ ifelse
+ Level2?
+ {
+ /_pdfFontStatus
+ {
+ currentglobal exch
+ /Font pdf_resourcestatus
+ {pop pop true}
+ {false}
+ ifelse
+ exch setglobal
+ } bd
+ }
+ {
+ /_pdfFontStatusString 50 string def
+ _pdfFontStatusString 0 (fonts/) putinterval
+ /_pdfFontStatus
+ {
+ FontDirectory 1 index known
+ { pop true }
+ {
+ _pdfFontStatusString 6 42 getinterval
+ cvs length 6 add
+ _pdfFontStatusString exch 0 exch getinterval
+ { status } stopped
+ {pop false}
+ {
+ { pop pop pop pop true}
+ { false }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ ifelse
+ Level2?
+ {
+ /_pdfCIDFontStatus
+ {
+ /CIDFont /Category pdf_resourcestatus
+ {
+ pop pop
+ /CIDFont pdf_resourcestatus
+ {pop pop true}
+ {false}
+ ifelse
+ }
+ { pop false }
+ ifelse
+ } bd
+ }
+ if
+ /_pdfString100 100 string def
+ /_pdfComposeFontName
+ {
+ dup length 1 eq
+ {
+ 0 get
+ 1 index
+ type /nametype eq
+ {
+ _pdfString100 cvs
+ length dup dup _pdfString100 exch (-) putinterval
+ _pdfString100 exch 1 add dup _pdfString100 length exch sub getinterval
+ 2 index exch cvs length
+ add 1 add _pdfString100 exch 0 exch getinterval
+ exch pop
+ true
+ }
+ {
+ pop pop
+ false
+ }
+ ifelse
+ }
+ {
+ false
+ }
+ ifelse
+ dup {exch cvn exch} if
+ } bd
+ /_pdfConcatNames
+ {
+ exch
+ _pdfString100 cvs
+ length dup dup _pdfString100 exch (-) putinterval
+ _pdfString100 exch 1 add dup _pdfString100 length exch sub getinterval
+ 3 -1 roll exch cvs length
+ add 1 add _pdfString100 exch 0 exch getinterval
+ cvn
+ } bind def
+ /_pdfTextTempString 50 string def
+ /_pdfRegOrderingArray [(Adobe-Japan1) (Adobe-CNS1) (Adobe-Korea1) (Adobe-GB1)] def
+ /_pdf_CheckCIDSystemInfo
+ {
+ 1 index _pdfTextTempString cvs
+ (Identity) anchorsearch
+ {
+ pop pop pop pop true
+ }
+ {
+ false
+ _pdfRegOrderingArray
+ {
+ 2 index exch
+ anchorsearch
+ { pop pop pop true exit}
+ { pop }
+ ifelse
+ }
+ forall
+ exch pop
+ exch /CIDFont findresource
+ /CIDSystemInfo get
+ 3 -1 roll /CMap findresource
+ /CIDSystemInfo get
+ exch
+ 3 -1 roll
+ {
+ 2 copy
+ /Supplement get
+ exch
+ dup type /dicttype eq
+ {/Supplement get}
+ {pop 0 }
+ ifelse
+ ge
+ }
+ { true }
+ ifelse
+ {
+ dup /Registry get
+ 2 index /Registry get eq
+ {
+ /Ordering get
+ exch /Ordering get
+ dup type /arraytype eq
+ {
+ 1 index type /arraytype eq
+ {
+ true
+ 1 index length 1 sub -1 0
+ {
+ dup 2 index exch get exch 3 index exch get ne
+ { pop false exit}
+ if
+ } for
+ exch pop exch pop
+ }
+ { pop pop false }
+ ifelse
+ }
+ {
+ eq
+ }
+ ifelse
+ }
+ { pop pop false }
+ ifelse
+ }
+ { pop pop false }
+ ifelse
+ }
+ ifelse
+ } bind def
+ pdf_has_composefont?
+ {
+ /_pdfComposeFont
+ {
+ 2 copy _pdfComposeFontName not
+ {
+ 2 index
+ }
+ if
+ (pdf) exch _pdfConcatNames
+ dup _pdfFontStatus
+ { dup findfont 5 2 roll pop pop pop true}
+ {
+ 4 1 roll
+ 1 index /CMap pdf_resourcestatus
+ {
+ pop pop
+ true
+ }
+ {false}
+ ifelse
+ 1 index true exch
+ {
+ _pdfCIDFontStatus not
+ {pop false exit}
+ if
+ }
+ forall
+ and
+ {
+ 1 index 1 index 0 get _pdf_CheckCIDSystemInfo
+ {
+ 3 -1 roll pop
+ 2 index 3 1 roll
+ composefont true
+ }
+ {
+ pop pop exch pop false
+ }
+ ifelse
+ }
+ {
+ _pdfComposeFontName
+ {
+ dup _pdfFontStatus
+ {
+ exch pop
+ 1 index exch
+ findfont definefont true
+ }
+ {
+ pop exch pop
+ false
+ }
+ ifelse
+ }
+ {
+ exch pop
+ false
+ }
+ ifelse
+ }
+ ifelse
+ { true }
+ {
+ dup _pdfFontStatus
+ { dup findfont true }
+ { pop false }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ {
+ /_pdfComposeFont
+ {
+ _pdfComposeFontName not
+ {
+ dup
+ }
+ if
+ dup
+ _pdfFontStatus
+ {exch pop dup findfont true}
+ {
+ 1 index
+ dup type /nametype eq
+ {pop}
+ {cvn}
+ ifelse
+ eq
+ {pop false}
+ {
+ dup _pdfFontStatus
+ {dup findfont true}
+ {pop false}
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ }
+ ifelse
+ /_pdfStyleDicts 4 dict dup begin
+ /Adobe-Japan1 4 dict dup begin
+ Level2?
+ {
+ /Serif
+ /HeiseiMin-W3-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiMin-W3}
+ {
+ /HeiseiMin-W3 _pdfCIDFontStatus
+ {/HeiseiMin-W3}
+ {/Ryumin-Light}
+ ifelse
+ }
+ ifelse
+ def
+ /SansSerif
+ /HeiseiKakuGo-W5-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiKakuGo-W5}
+ {
+ /HeiseiKakuGo-W5 _pdfCIDFontStatus
+ {/HeiseiKakuGo-W5}
+ {/GothicBBB-Medium}
+ ifelse
+ }
+ ifelse
+ def
+ /HeiseiMaruGo-W4-83pv-RKSJ-H _pdfFontStatus
+ {/HeiseiMaruGo-W4}
+ {
+ /HeiseiMaruGo-W4 _pdfCIDFontStatus
+ {/HeiseiMaruGo-W4}
+ {
+ /Jun101-Light-RKSJ-H _pdfFontStatus
+ { /Jun101-Light }
+ { SansSerif }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ /RoundSansSerif exch def
+ /Default Serif def
+ }
+ {
+ /Serif /Ryumin-Light def
+ /SansSerif /GothicBBB-Medium def
+ {
+ (fonts/Jun101-Light-83pv-RKSJ-H) status
+ }stopped
+ {pop}{
+ { pop pop pop pop /Jun101-Light }
+ { SansSerif }
+ ifelse
+ /RoundSansSerif exch def
+ }ifelse
+ /Default Serif def
+ }
+ ifelse
+ end
+ def
+ /Adobe-Korea1 4 dict dup begin
+ /Serif /HYSMyeongJo-Medium def
+ /SansSerif /HYGoThic-Medium def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ /Adobe-GB1 4 dict dup begin
+ /Serif /STSong-Light def
+ /SansSerif /STHeiti-Regular def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ /Adobe-CNS1 4 dict dup begin
+ /Serif /MKai-Medium def
+ /SansSerif /MHei-Medium def
+ /RoundSansSerif SansSerif def
+ /Default Serif def
+ end
+ def
+ end
+ def
+ /TZzero
+ {
+ /_wmode xdd
+ /_styleArr xdd
+ /_regOrdering xdd
+ 3 copy
+ _pdfComposeFont
+ {
+ 5 2 roll pop pop pop
+ }
+ {
+ [
+ 0 1 _styleArr length 1 sub
+ {
+ _styleArr exch get
+ _pdfStyleDicts _regOrdering 2 copy known
+ {
+ get
+ exch 2 copy known not
+ { pop /Default }
+ if
+ get
+ }
+ {
+ pop pop pop /Unknown
+ }
+ ifelse
+ }
+ for
+ ]
+ exch pop
+ 2 index 3 1 roll
+ _pdfComposeFont
+ {3 -1 roll pop}
+ {
+ findfont dup /FontName get exch
+ }
+ ifelse
+ }
+ ifelse
+ dup /WMode 2 copy known
+ { get _wmode ne }
+ { pop pop _wmode 1 eq}
+ ifelse
+ {
+ exch _wmode _pdfConcatNames
+ dup _pdfFontStatus
+ { exch pop dup findfont false}
+ { exch true }
+ ifelse
+ }
+ {
+ dup /FontType get 0 ne
+ }
+ ifelse
+ {
+ dup /FontType get 3 eq _wmode 1 eq and
+ {
+ _pdfVerticalRomanT3Font dup length 10 add dict copy
+ begin
+ /_basefont exch
+ dup length 3 add dict
+ begin
+ {1 index /FID ne {def}{pop pop} ifelse }
+ forall
+ /Encoding Encoding dup length array copy
+ dup 16#27 /quotesingle put
+ dup 16#60 /grave put
+ _regOrdering /Adobe-Japan1 eq
+ {dup 16#5c /yen put dup 16#a5 /yen put dup 16#b4 /yen put}
+ if
+ def
+ FontName
+ currentdict
+ end
+ definefont
+ def
+ /Encoding _basefont /Encoding get def
+ /_fauxfont true def
+ }
+ {
+ dup length 3 add dict
+ begin
+ {1 index /FID ne {def}{pop pop} ifelse }
+ forall
+ FontType 0 ne
+ {
+ /Encoding Encoding dup length array copy
+ dup 16#27 /quotesingle put
+ dup 16#60 /grave put
+ _regOrdering /Adobe-Japan1 eq
+ {dup 16#5c /yen put}
+ if
+ def
+ /_fauxfont true def
+ } if
+ } ifelse
+ /WMode _wmode def
+ dup dup /FontName exch def
+ currentdict
+ end
+ definefont pop
+ }
+ {
+ pop
+ }
+ ifelse
+ /_pdf_FontDirectory 3 1 roll _safeput
+ }
+ bd
+ Level2?
+ {
+ /Tf {
+ _pdf_FontDirectory 2 index 2 copy known
+ {get exch 3 -1 roll pop}
+ {pop pop}
+ ifelse
+ selectfont
+ } bd
+ }
+ {
+ /Tf {
+ _pdf_FontDirectory 2 index 2 copy known
+ {get exch 3 -1 roll pop}
+ {pop pop}
+ ifelse
+ exch findfont exch
+ dup type /arraytype eq
+ {makefont}
+ {scalefont}
+ ifelse
+ setfont
+ } bd
+ }
+ ifelse
+ /cshow where
+ {
+ pop /pdf_cshow /cshow load dd
+ /pdf_remove2 {pop pop} dd
+ }
+ {
+ /pdf_cshow {exch forall} dd
+ /pdf_remove2 {} dd
+ } ifelse
+ /pdf_xshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ _pdf_x _pdf_y moveto
+ 0
+ rmoveto
+ }
+ ifelse
+ _pdf_i 1 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdf_yshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ _pdf_x _pdf_y moveto
+ 0 exch
+ rmoveto
+ }
+ ifelse
+ _pdf_i 1 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdf_xyshow
+ {
+ /_pdf_na xdd
+ /_pdf_i 0 dd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 /_pdf_showproc load exec
+ {_pdf_na _pdf_i get} stopped
+ { pop pop }
+ {
+ {_pdf_na _pdf_i 1 add get} stopped
+ { pop pop pop}
+ {
+ _pdf_x _pdf_y moveto
+ rmoveto
+ }
+ ifelse
+ }
+ ifelse
+ _pdf_i 2 add /_pdf_i xdd
+ currentpoint
+ /_pdf_y xdd
+ /_pdf_x xdd
+ }
+ exch
+ pdf_cshow
+ } bd
+ /pdfl1xs {/_pdf_showproc /show load dd pdf_xshow} bd
+ /pdfl1ys {/_pdf_showproc /show load dd pdf_yshow} bd
+ /pdfl1xys {/_pdf_showproc /show load dd pdf_xyshow} bd
+ Level2? _ColorSep5044? not and
+ {
+ /pdfxs {{xshow} stopped {pdfl1xs} if} bd
+ /pdfys {{yshow} stopped {pdfl1ys} if} bd
+ /pdfxys {{xyshow} stopped {pdfl1xys} if} bd
+ }
+ {
+ /pdfxs /pdfl1xs load dd
+ /pdfys /pdfl1ys load dd
+ /pdfxys /pdfl1xys load dd
+ } ifelse
+ /pdf_charpath {false charpath} bd
+ /pdf_xcharpath {/_pdf_showproc /pdf_charpath load dd pdf_xshow} bd
+ /pdf_ycharpath {/_pdf_showproc /pdf_charpath load dd pdf_yshow} bd
+ /pdf_xycharpath {/_pdf_showproc /pdf_charpath load dd pdf_xyshow} bd
+ /pdf_strokepath
+ {
+ {
+ pdf_remove2
+ _pdf_str1 exch 0 exch put
+ _pdf_str1 false charpath
+ currentpoint S moveto
+ } bind
+ exch pdf_cshow
+ } bd
+ /pdf_xstrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_xshow} bd
+ /pdf_ystrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_yshow} bd
+ /pdf_xystrokepath {/_pdf_showproc {pdf_charpath S} dd pdf_xyshow} bd
+ Level2? {currentglobal true setglobal} if
+ /d0/setcharwidth ld
+ /nND {{/.notdef} repeat} bd
+ /T3Defs {
+ /BuildChar
+ {
+ 1 index /Encoding get exch get
+ 1 index /BuildGlyph get exec
+ }
+ def
+ /BuildGlyph {
+ exch begin
+ GlyphProcs exch get exec
+ end
+ } def
+ /_pdfT3Font true def
+ } bd
+ /_pdfBoldRomanWidthProc
+ {
+ stringwidth 1 index 0 ne { exch .03 add exch }if setcharwidth
+ 0 0
+ } bd
+ /_pdfType0WidthProc
+ {
+ dup stringwidth 0 0 moveto
+ 2 index true charpath pathbbox
+ 0 -1
+ 7 index 2 div .88
+ setcachedevice2
+ pop
+ 0 0
+ } bd
+ /_pdfType0WMode1WidthProc
+ {
+ dup stringwidth
+ pop 2 div neg -0.88
+ 2 copy
+ moveto
+ 0 -1
+ 5 -1 roll true charpath pathbbox
+ setcachedevice
+ } bd
+ /_pdfBoldBaseFont
+ 11 dict begin
+ /FontType 3 def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /Encoding cHexEncoding def
+ /_setwidthProc /_pdfBoldRomanWidthProc load def
+ /_bcstr1 1 string def
+ /BuildChar
+ {
+ exch begin
+ _basefont setfont
+ _bcstr1 dup 0 4 -1 roll put
+ dup
+ _setwidthProc
+ 3 copy
+ moveto
+ show
+ _basefonto setfont
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ pdf_has_composefont?
+ {
+ /_pdfBoldBaseCIDFont
+ 11 dict begin
+ /CIDFontType 1 def
+ /CIDFontName /_pdfBoldBaseCIDFont def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /_setwidthProc /_pdfType0WidthProc load def
+ /_bcstr2 2 string def
+ /BuildGlyph
+ {
+ exch begin
+ _basefont setfont
+ _bcstr2 1 2 index 256 mod put
+ _bcstr2 0 3 -1 roll 256 idiv put
+ _bcstr2 dup _setwidthProc
+ 3 copy
+ moveto
+ show
+ _basefonto setfont
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ /_pdfDefineIdentity-H
+ {
+ /Identity-H /CMap PDFText /pdf_resourcestatus get exec
+ {
+ pop pop
+ }
+ {
+ /CIDInit/ProcSet findresource begin 12 dict begin
+ begincmap
+ /CIDSystemInfo
+ 3 dict begin
+ /Registry (Adobe) def
+ /Ordering (Identity) def
+ /Supplement 0 def
+ currentdict
+ end
+ def
+ /CMapName /Identity-H def
+ /CMapVersion 1 def
+ /CMapType 1 def
+ 1 begincodespacerange
+ <0000> 
+ endcodespacerange
+ 1 begincidrange
+ <0000>  0
+ endcidrange
+ endcmap
+ CMapName currentdict/CMap defineresource pop
+ end
+ end
+ } ifelse
+ } def
+ } if
+ /_pdfVerticalRomanT3Font
+ 10 dict begin
+ /FontType 3 def
+ /FontMatrix[1 0 0 1 0 0]def
+ /FontBBox[0 0 1 1]def
+ /_bcstr1 1 string def
+ /BuildChar
+ {
+ exch begin
+ _basefont setfont
+ _bcstr1 dup 0 4 -1 roll put
+ dup
+ _pdfType0WidthProc
+ moveto
+ show
+ end
+ }bd
+ currentdict
+ end
+ def
+ Level2? {setglobal} if
+ /MakeBoldFont
+ {
+ dup /ct_SyntheticBold known
+ {
+ dup length 3 add dict begin
+ CopyFont
+ /ct_StrokeWidth .03 0 FontMatrix idtransform pop def
+ /ct_SyntheticBold true def
+ currentdict
+ end
+ definefont
+ }
+ {
+ dup dup length 3 add dict
+ begin
+ CopyFont
+ /PaintType 2 def
+ /StrokeWidth .03 0 FontMatrix idtransform pop def
+ /dummybold currentdict
+ end
+ definefont
+ dup /FontType get dup 9 ge exch 11 le and
+ {
+ _pdfBoldBaseCIDFont
+ dup length 3 add dict copy begin
+ dup /CIDSystemInfo get /CIDSystemInfo exch def
+ /_Type0Identity /Identity-H 3 -1 roll [ exch ] composefont
+ /_basefont exch def
+ /_Type0Identity /Identity-H 3 -1 roll [ exch ] composefont
+ /_basefonto exch def
+ currentdict
+ end
+ /CIDFont defineresource
+ }
+ {
+ _pdfBoldBaseFont
+ dup length 3 add dict copy begin
+ /_basefont exch def
+ /_basefonto exch def
+ currentdict
+ end
+ definefont
+ }
+ ifelse
+ }
+ ifelse
+ } bd
+ /MakeBold {
+ 1 index
+ _pdf_FontDirectory 2 index 2 copy known
+ {get}
+ {exch pop}
+ ifelse
+ findfont
+ dup
+ /FontType get 0 eq
+ {
+ dup /WMode known {dup /WMode get 1 eq }{false} ifelse
+ version length 4 ge
+ and
+ {version 0 4 getinterval cvi 2015 ge }
+ {true}
+ ifelse
+ {/_pdfType0WidthProc}
+ {/_pdfType0WMode1WidthProc}
+ ifelse
+ _pdfBoldBaseFont /_setwidthProc 3 -1 roll load put
+ {MakeBoldFont} Type0CopyFont definefont
+ }
+ {
+ dup /_fauxfont known not 1 index /SubstMaster known not and
+ {
+ _pdfBoldBaseFont /_setwidthProc /_pdfBoldRomanWidthProc load put
+ MakeBoldFont
+ }
+ {
+ 2 index 2 index eq
+ { exch pop }
+ {
+ dup length dict begin
+ CopyFont
+ currentdict
+ end
+ definefont
+ }
+ ifelse
+ }
+ ifelse
+ }
+ ifelse
+ pop pop
+ dup /dummybold ne
+ {/_pdf_FontDirectory exch dup _safeput }
+ { pop }
+ ifelse
+ }bd
+ /MakeItalic {
+ _pdf_FontDirectory exch 2 copy known
+ {get}
+ {exch pop}
+ ifelse
+ dup findfont
+ dup /FontInfo 2 copy known
+ {
+ get
+ /ItalicAngle 2 copy known
+ {get 0 eq }
+ { pop pop true}
+ ifelse
+ }
+ { pop pop true}
+ ifelse
+ {
+ exch pop
+ dup /FontType get 0 eq Level2? not and
+ { dup /FMapType get 6 eq }
+ { false }
+ ifelse
+ {
+ dup /WMode 2 copy known
+ {
+ get 1 eq
+ { _italMtx_WMode1Type0 }
+ { _italMtxType0 }
+ ifelse
+ }
+ { pop pop _italMtxType0 }
+ ifelse
+ }
+ {
+ dup /WMode 2 copy known
+ {
+ get 1 eq
+ { _italMtx_WMode1 }
+ { _italMtx }
+ ifelse
+ }
+ { pop pop _italMtx }
+ ifelse
+ }
+ ifelse
+ makefont
+ dup /FontType get 42 eq Level2? not or
+ {
+ dup length dict begin
+ CopyFont
+ currentdict
+ end
+ }
+ if
+ 1 index exch
+ definefont pop
+ /_pdf_FontDirectory exch dup _safeput
+ }
+ {
+ pop
+ 2 copy ne
+ {
+ /_pdf_FontDirectory 3 1 roll _safeput
+ }
+ { pop pop }
+ ifelse
+ }
+ ifelse
+ }bd
+ /MakeBoldItalic {
+ /dummybold exch
+ MakeBold
+ /dummybold
+ MakeItalic
+ }bd
+ Level2?
+ {
+ /pdf_CopyDict
+ {1 index length add dict copy}
+ def
+ }
+ {
+ /pdf_CopyDict
+ {
+ 1 index length add dict
+ 1 index wcheck
+ { copy }
+ { begin
+ {def} forall
+ currentdict
+ end
+ }
+ ifelse
+ }
+ def
+ }
+ ifelse
+ /pdf_AddEuroGlyphProc
+ {
+ currentdict /CharStrings known
+ {
+ CharStrings /Euro known not
+ {
+ dup
+ /CharStrings
+ CharStrings 1 pdf_CopyDict
+ begin
+ /Euro pdf_EuroProcSet 4 -1 roll get def
+ currentdict
+ end
+ def
+ /pdf_PSBuildGlyph /pdf_PSBuildGlyph load def
+ /pdf_PathOps /pdf_PathOps load def
+ /Symbol eq
+ {
+ /Encoding Encoding dup length array copy
+ dup 160 /Euro put def
+ }
+ if
+ }
+ { pop
+ }
+ ifelse
+ }
+ { pop
+ }
+ ifelse
+ }
+ def
+ Level2? {currentglobal true setglobal} if
+ /pdf_PathOps 4 dict dup begin
+ /m {moveto} def
+ /l {lineto} def
+ /c {curveto} def
+ /cp {closepath} def
+ end
+ def
+ /pdf_PSBuildGlyph
+ {
+ gsave
+ 8 -1 roll pop
+ 7 1 roll
+ currentdict /PaintType 2 copy known {get 2 eq}{pop pop false} ifelse
+ dup 9 1 roll
+ {
+ currentdict /StrokeWidth 2 copy known
+ {
+ get 2 div
+ 5 1 roll
+ 4 -1 roll 4 index sub
+ 4 1 roll
+ 3 -1 roll 4 index sub
+ 3 1 roll
+ exch 4 index add exch
+ 4 index add
+ 5 -1 roll pop
+ }
+ {
+ pop pop
+ }
+ ifelse
+ }
+ if
+ setcachedevice
+ pdf_PathOps begin
+ exec
+ end
+ {
+ currentdict /StrokeWidth 2 copy known
+ { get }
+ { pop pop 0 }
+ ifelse
+ setlinewidth stroke
+ }
+ {
+ fill
+ }
+ ifelse
+ grestore
+ } def
+ /pdf_EuroProcSet 13 dict def
+ pdf_EuroProcSet
+ begin
+ /Courier-Bold
+ {
+ 600 0 6 -12 585 612
+ {
+ 385 274 m
+ 180 274 l
+ 179 283 179 293 179 303 c
+ 179 310 179 316 180 323 c
+ 398 323 l
+ 423 404 l
+ 197 404 l
+ 219 477 273 520 357 520 c
+ 409 520 466 490 487 454 c
+ 487 389 l
+ 579 389 l
+ 579 612 l
+ 487 612 l
+ 487 560 l
+ 449 595 394 612 349 612 c
+ 222 612 130 529 98 404 c
+ 31 404 l
+ 6 323 l
+ 86 323 l
+ 86 304 l
+ 86 294 86 284 87 274 c
+ 31 274 l
+ 6 193 l
+ 99 193 l
+ 129 77 211 -12 359 -12 c
+ 398 -12 509 8 585 77 c
+ 529 145 l
+ 497 123 436 80 356 80 c
+ 285 80 227 122 198 193 c
+ 360 193 l
+ cp
+ 600 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Courier-BoldOblique /Courier-Bold load def
+ /Courier
+ {
+ 600 0 17 -12 578 584
+ {
+ 17 204 m
+ 97 204 l
+ 126 81 214 -12 361 -12 c
+ 440 -12 517 17 578 62 c
+ 554 109 l
+ 501 70 434 43 366 43 c
+ 266 43 184 101 154 204 c
+ 380 204 l
+ 400 259 l
+ 144 259 l
+ 144 270 143 281 143 292 c
+ 143 299 143 307 144 314 c
+ 418 314 l
+ 438 369 l
+ 153 369 l
+ 177 464 249 529 345 529 c
+ 415 529 484 503 522 463 c
+ 522 391 l
+ 576 391 l
+ 576 584 l
+ 522 584 l
+ 522 531 l
+ 473 566 420 584 348 584 c
+ 216 584 122 490 95 369 c
+ 37 369 l
+ 17 314 l
+ 87 314 l
+ 87 297 l
+ 87 284 88 272 89 259 c
+ 37 259 l
+ cp
+ 600 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Courier-Oblique /Courier load def
+ /Helvetica
+ {
+ 556 0 24 -19 541 703
+ {
+ 541 628 m
+ 510 669 442 703 354 703 c
+ 201 703 117 607 101 444 c
+ 50 444 l
+ 25 372 l
+ 97 372 l
+ 97 301 l
+ 49 301 l
+ 24 229 l
+ 103 229 l
+ 124 67 209 -19 350 -19 c
+ 435 -19 501 25 509 32 c
+ 509 131 l
+ 492 105 417 60 343 60 c
+ 267 60 204 127 197 229 c
+ 406 229 l
+ 430 301 l
+ 191 301 l
+ 191 372 l
+ 455 372 l
+ 479 444 l
+ 194 444 l
+ 201 531 245 624 348 624 c
+ 433 624 484 583 509 534 c
+ cp
+ 556 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Helvetica-Oblique /Helvetica load def
+ /Helvetica-Bold
+ {
+ 556 0 12 -19 563 710
+ {
+ 563 621 m
+ 537 659 463 710 363 710 c
+ 216 710 125 620 101 462 c
+ 51 462 l
+ 12 367 l
+ 92 367 l
+ 92 346 l
+ 92 337 93 328 93 319 c
+ 52 319 l
+ 12 224 l
+ 102 224 l
+ 131 58 228 -19 363 -19 c
+ 417 -19 471 -12 517 18 c
+ 517 146 l
+ 481 115 426 93 363 93 c
+ 283 93 254 166 246 224 c
+ 398 224 l
+ 438 319 l
+ 236 319 l
+ 236 367 l
+ 457 367 l
+ 497 462 l
+ 244 462 l
+ 259 552 298 598 363 598 c
+ 425 598 464 570 486 547 c
+ 507 526 513 517 517 509 c
+ cp
+ 556 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Helvetica-BoldOblique /Helvetica-Bold load def
+ /Symbol
+ {
+ 750 0 20 -12 714 685
+ {
+ 714 581 m
+ 650 645 560 685 465 685 c
+ 304 685 165 580 128 432 c
+ 50 432 l
+ 20 369 l
+ 116 369 l
+ 115 356 115 347 115 337 c
+ 115 328 115 319 116 306 c
+ 50 306 l
+ 20 243 l
+ 128 243 l
+ 165 97 300 -12 465 -12 c
+ 560 -12 635 25 685 65 c
+ 685 155 l
+ 633 91 551 51 465 51 c
+ 340 51 238 131 199 243 c
+ 555 243 l
+ 585 306 l
+ 184 306 l
+ 183 317 182 326 182 336 c
+ 182 346 183 356 184 369 c
+ 614 369 l 644 432 l
+ 199 432 l
+ 233 540 340 622 465 622 c
+ 555 622 636 580 685 520 c
+ cp
+ 750 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Bold
+ {
+ 500 0 16 -14 478 700
+ {
+ 367 308 m
+ 224 308 l
+ 224 368 l
+ 375 368 l
+ 380 414 l
+ 225 414 l
+ 230 589 257 653 315 653 c
+ 402 653 431 521 444 457 c
+ 473 457 l
+ 473 698 l
+ 444 697 l
+ 441 679 437 662 418 662 c
+ 393 662 365 700 310 700 c
+ 211 700 97 597 73 414 c
+ 21 414 l
+ 16 368 l
+ 69 368 l
+ 69 359 68 350 68 341 c
+ 68 330 68 319 69 308 c
+ 21 308 l
+ 16 262 l
+ 73 262 l
+ 91 119 161 -14 301 -14 c
+ 380 -14 443 50 478 116 c
+ 448 136 l
+ 415 84 382 40 323 40 c
+ 262 40 231 77 225 262 c
+ 362 262 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-BoldItalic
+ {
+ 500 0 9 -20 542 686
+ {
+ 542 686 m
+ 518 686 l
+ 513 673 507 660 495 660 c
+ 475 660 457 683 384 683 c
+ 285 683 170 584 122 430 c
+ 58 430 l
+ 34 369 l
+ 105 369 l
+ 101 354 92 328 90 312 c
+ 34 312 l
+ 9 251 l
+ 86 251 l
+ 85 238 84 223 84 207 c
+ 84 112 117 -14 272 -14 c
+ 326 -14 349 9 381 9 c
+ 393 9 393 -10 394 -20 c
+ 420 -20 l
+ 461 148 l
+ 429 148 l
+ 416 109 362 15 292 15 c
+ 227 15 197 55 197 128 c
+ 197 162 204 203 216 251 c
+ 378 251 l
+ 402 312 l
+ 227 312 l
+ 229 325 236 356 241 369 c
+ 425 369 l
+ 450 430 l
+ 255 430 l
+ 257 435 264 458 274 488 c
+ 298 561 337 654 394 654 c
+ 437 654 484 621 484 530 c
+ 484 516 l
+ 516 516 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Italic
+ {
+ 500 0 23 -10 595 692
+ {
+ 399 317 m
+ 196 317 l
+ 199 340 203 363 209 386 c
+ 429 386 l
+ 444 424 l
+ 219 424 l
+ 246 514 307 648 418 648 c
+ 448 648 471 638 492 616 c
+ 529 576 524 529 527 479 c
+ 549 475 l
+ 595 687 l
+ 570 687 l
+ 562 674 558 664 542 664 c
+ 518 664 474 692 423 692 c
+ 275 692 162 551 116 424 c
+ 67 424 l
+ 53 386 l
+ 104 386 l
+ 98 363 93 340 90 317 c
+ 37 317 l
+ 23 279 l
+ 86 279 l
+ 85 266 85 253 85 240 c
+ 85 118 137 -10 277 -10 c
+ 370 -10 436 58 488 128 c
+ 466 149 l
+ 424 101 375 48 307 48 c
+ 212 48 190 160 190 234 c
+ 190 249 191 264 192 279 c
+ 384 279 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ /Times-Roman
+ {
+ 500 0 10 -12 484 692
+ {
+ 347 298 m
+ 171 298 l
+ 170 310 170 322 170 335 c
+ 170 362 l
+ 362 362 l
+ 374 403 l
+ 172 403 l
+ 184 580 244 642 308 642 c
+ 380 642 434 574 457 457 c
+ 481 462 l
+ 474 691 l
+ 449 691 l
+ 433 670 429 657 410 657 c
+ 394 657 360 692 299 692 c
+ 204 692 94 604 73 403 c
+ 22 403 l
+ 10 362 l
+ 70 362 l
+ 69 352 69 341 69 330 c
+ 69 319 69 308 70 298 c
+ 22 298 l
+ 10 257 l
+ 73 257 l
+ 97 57 216 -12 295 -12 c
+ 364 -12 427 25 484 123 c
+ 458 142 l
+ 425 101 384 37 316 37 c
+ 256 37 189 84 173 257 c
+ 335 257 l
+ cp
+ 500 0 m
+ }
+ pdf_PSBuildGlyph
+ } def
+ end
+ Level2? {setglobal} if
+ currentdict readonly pop end
+ %%EndResource
+ PDFText begin
+ [userdict /pdf_svglb currentglobal put true setglobal
+ 39/quotesingle 96/grave 128/Adieresis/Aring/Ccedilla/Eacute/Ntilde/Odieresis
+ /Udieresis/aacute/agrave/acircumflex/adieresis/atilde/aring/ccedilla/eacute
+ /egrave/ecircumflex/edieresis/iacute/igrave/icircumflex/idieresis/ntilde
+ /oacute/ograve/ocircumflex/odieresis/otilde/uacute/ugrave/ucircumflex
+ /udieresis/dagger/degree/cent/sterling/section/bullet/paragraph/germandbls
+ /registered/copyright/trademark/acute/dieresis/.notdef/AE/Oslash
+ /.notdef/plusminus/.notdef/.notdef/yen/mu/.notdef/.notdef
+ /.notdef/.notdef/.notdef/ordfeminine/ordmasculine/.notdef/ae/oslash
+ /questiondown/exclamdown/logicalnot/.notdef/florin/.notdef/.notdef
+ /guillemotleft/guillemotright/ellipsis/space/Agrave/Atilde/Otilde/OE/oe
+ /endash/emdash/quotedblleft/quotedblright/quoteleft/quoteright/divide
+ /.notdef/ydieresis/Ydieresis/fraction/currency/guilsinglleft/guilsinglright
+ /fi/fl/daggerdbl/periodcentered/quotesinglbase/quotedblbase/perthousand
+ /Acircumflex/Ecircumflex/Aacute/Edieresis/Egrave/Iacute/Icircumflex
+ /Idieresis/Igrave/Oacute/Ocircumflex/.notdef/Ograve/Uacute/Ucircumflex
+ /Ugrave/dotlessi/circumflex/tilde/macron/breve/dotaccent/ring/cedilla
+ /hungarumlaut/ogonek/caron
+ 0 TE
+ [1/dotlessi/caron 39/quotesingle 96/grave 
+ 127/bullet/Euro/bullet/quotesinglbase/florin/quotedblbase/ellipsis
+ /dagger/daggerdbl/circumflex/perthousand/Scaron/guilsinglleft/OE
+ /bullet/Zcaron/bullet/bullet/quoteleft/quoteright/quotedblleft
+ /quotedblright/bullet/endash/emdash/tilde/trademark/scaron
+ /guilsinglright/oe/bullet/zcaron/Ydieresis/space/exclamdown/cent/sterling
+ /currency/yen/brokenbar/section/dieresis/copyright/ordfeminine
+ /guillemotleft/logicalnot/hyphen/registered/macron/degree/plusminus
+ /twosuperior/threesuperior/acute/mu/paragraph/periodcentered/cedilla
+ /onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters
+ /questiondown/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
+ /Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
+ /Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply/Oslash
+ /Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls/agrave
+ /aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla/egrave/eacute
+ /ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis/eth/ntilde
+ /ograve/oacute/ocircumflex/otilde/odieresis/divide/oslash/ugrave/uacute
+ /ucircumflex/udieresis/yacute/thorn/ydieresis
+ 1 TE
+ end
+ 
+ userdict /pdf_svglb get setglobal
+ currentdict readonly pop
+ end end
+ /currentpacking where {pop setpacking}if
+ PDFVars/DocInitAll{[PDF PDFText]{/docinitialize get exec}forall }put
+ PDFVars/InitAll{[PDF PDFText]{/initialize get exec}forall initgs}put
+ PDFVars/TermAll{[PDFText PDF]{/terminate get exec}forall}put
+ PDFVars begin PDF begin
+ PDFVars/DocInitAll get exec PDFVars/InitAll get exec
+ PDFVars/TermAll get exec end end
+ 
+ %%EndSetup
+ %%Page: 1 1
+ %%BeginPageSetup
+ userdict /pgsave save put
+ PDFVars begin PDF begin PDFVars/InitAll get exec
+ userdict /pdf_svglb currentglobal put true setglobal
+ %%BeginResource: font BAAAAA+NimbusRomNo9L-Regu
+ ct_CffDict begin
+ %!FontType1
+ 16 dict begin
+ /FontInfo 15 dict dup begin
+ /Notice (Copyright \050URW\051++,Copyright 1999 by \050URW\051++ Design & Development; Cyrillic glyphs added by Valek Filippov \050C\051 2001-2002; Numero, infinity and Omega made by Dmitry 40in \050C\051 2001) def
+ /version (1.06_2.0-11mdk) def
+ /FullName (Nimbus Roman No9 L Regular) def
+ /FamilyName (Nimbus Roman No9 L) def
+ /Weight (Regular) def
+ /ItalicAngle 0 def
+ /isFixedPitch false  def
+ /UnderlinePosition -100 def
+ /UnderlineThickness 50 def
+ end def
+ /FontName /BAAAAA+NimbusRomNo9L-Regu def
+ /Encoding 256 array
+ 0 1 255 {1 index exch /.notdef put} for
+ dup 0 /.notdef put
+  def
+ /PaintType 0 def
+ /FontType 1 def
+ /FontMatrix [0.001 0 0 0.001 0 0 ] def
+ /FontBBox { -168 -281 1031 924 } def
+ /XUID [6 5020931 ] def
+ /StrokeWidth 0 def
+ currentdict end
+ currentfile eexec A0B00ED5187D9C0F1ECDF51878C3AA5CAA3EC8DC423323
+ 00A152553EC9C9C51591C81BB5A2F58753878D92B1C73E948BB360F467A7D593
+ 2446E52E22935D5D0316634839C917AE2BE363D6AE3760363F748EAAEAD9AB74
+ D863835F45718D23FB3980D0C645610BF765847F4BC5CB03391BDC9D40A6A460
+ ABF0D95BB6A176DB5088A1068A0DFDC266C25ADCBEF3E5472E03E0D29BC6801F
+ A2AEAD77E33C825D7C534A1D7572F4904734D34A8EB5CCBF6AF4BD16868351B4
+ 9720597C58AD9250B850406E3B7095164E634F096B16B87B7EB1DA7059CE66FD
+ DF08D200E8C5AE20931835F16D7D7ECCDC34AB3F57D265C90F7F578F7CDE6C42
+ 2B637C476D8C9107DAA4DE8D4F2D7F84152BD4AB55B2AA432180A64B4259F798
+ BA386ECF68D89017904276D1BA4C8960B5AAA290FE93C3918D5FD9CA6CD88F81
+ E8F1799E9F58531B9C9A5FEA211CACC738184F6C443AC8652A08F84DF4BCC249
+ B245F255FED27A3FD4E0008E595C9411DD61472EB9A6B76D3B97E3E86ECE9662
+ CDDBBBDFA8751F2980D4C7F34CAE666319E178677831A93AE607295D07B858E1
+ BF91E80DBF21975B1D2AE6AB7704A0A333902C55D72B1A68E1F83EC77A7155EF
+ F414607204C8D13586ED60035A3964A8BD3EAE97F01688677C49644A9DC05D73
+ 1DCA46F205AFBD07E21DDAA61B5CC76DD51ACBFAFB22A1A7CBB3ED35AA88785C
+ D6BDB6F0B4A3A88511E4C245E31F24A89CD0C73901AF2F97B52CC37BB93AA75B
+ AC51A455BF3D0419C309F18B2F21512D22A1FFBC26DA689B02EC6A156CC90220
+ 80CE0122B8484182F4DC68D202EEA7A385CD2C0602C6B06CA2423EF4E5B7A9FD
+ 8065F58DC20F0564BDC9FCF604482C6A9961C1BD4BAE67B66A0ED9F7588F56DD
+ 298327F7AFC3DD2E6B370AEDAC3A5EEB34BBA66F4969F8B4BE519A75D7C13C69
+ 14A9DE574E3E55B6473C33CF423DDCC61101E387245B975948CA2F8F8CF0328B
+ 532F07497A7DF747D34290588F915388C74E3C2FB5A4AB6938B198E51046FB8E
+ A62B5B50A2CFCAB0204487CBE7594C99E5FE0EE1F2119F31E302E0B83063FBB3
+ D450000EF21EC2E12F88C10E68A80B3EC4494C88781A6A9E604E916F626F167C
+ 98C1E2F844495404F9A72BE1E65839E5984036BE70DED7DD7FDCCB939CE0F0FE
+ C49C4BD7FF565C235C3DC010199F222C88A9068D8C75F6108BD777EBE007C372
+ AD292EB5A7B535AF33089C6FA236522441AA33E059DAC73E0B4A1EEC2D82E045
+ CB1AC8F10C892D9E9AD16F752629DE78F960AED22F4AEA1436DE4DCA9C26AFD8
+ C56499F70BAB90BDB0D89EAA59E31E1A7AA8F35E18C6844648FA14D72982A1C0
+ 1EA6B968C8A7861D67CB5518B7243677CBF8875AC60BA0463791531696D2DBC5
+ 4587334341431A8A061A553F4CF7D5369ED4BF95968FA73C63E5A9A8B7FD1AA5
+ 9CB121C1046586A2DCD4925CCBA76B767E7E4CDB7ED8A1CBC9A56F4EDFF61857
+ D8FF0CA6C39C82475053376AA2CCE5C7CAE5B023EF9D80989C971EE303B01AE7
+ D6730CAE40B82ADAB315FDB991F834E7F201B38249D5EFB2FC529F106DFB3907
+ B08FE77CE4A8E43EF9D09CF219D0764758D72BA189672759CE7CF8A58BAC0A7D
+ 5A7175462119B106EA55463DD4C110BC7FA69D33A5408A02FBC994009B6D5F7C
+ 54C16B1BBEAB0C04F215BD3783CDF915E2C1015F0191AFE7CCF51CD883AA8576
+ 86A237EFCFBE0C9851E4B4277C103C7F206A7234F1C0BCCB55C9C0304301B6A4
+ 301C34EABE7515DD1301657ED226325927EEE0379DAF9A80E445AA7CDC55C141
+ 9165E2ED0F3B025C3F12627C2266CEB1EBAE434DEAA5E89CBCA8B976A02E6CC6
+ CC37DA12B5AFF7300F909FD73A88E55F5FEC85310C6DADF134201F6CB7420106
+ 487DAB97B2DC88B90DD53ECA449D5A57ABCAA636A41923351149EEBC46545716
+ FF279DF1308F557A0A61339B0781AE88A3C4DC99233271726C1FA3A2277B5012
+ C800BA03AFD7CB70A7B61C3953EC02E20DD1214CBB8DBEF501A0FE578374434F
+ E5E38A2138F603702338CCCBA7B10D1BC0696B80398199B849DF9AC91407FB5F
+ 73387CDABF0D70570167E28C95375DAD3176051C9167F05FC9E5A4EB64B4EF85
+ 147E75C179F5DE1BEC54898014040D34EDAB78408FF3DF179539CD1D78DB1961
+ 9F64FDC62623B45D9451F0E0E84C82E38FEA4A2FB7B1AC764C2BB7A54E7F2F81
+ 3D5320D9FE17A8F69C8F9BE8E018CF1B057838C5DE06A986709523855F2F486D
+ 6DB186B70AD3EAEA14C66229AA16D95E42868888C7EF9E0ECA8EF45E75242FF6
+ CCA1BD1BA9D5F80D85FE2CA3103A165FEC935F15FB973D0C07D7AB46D04B3B3A
+ 07C7262821170D3747C7D46520836B7155C3FAAE5340E5675B5F83385181CCDF
+ 24D4D21482C7F1F467B8EB1B4642ED35B95517FA92598C12004FE4FF06CF0D25
+ DA2B1B6EE234C2D8217FEE5C1663BF21829737DC9BA434032887C50FCAD17DCA
+ 0AE003EF0B5AA2C17397E926E5EA036E833E970FFF7F51CC837A4C619D862FB3
+ 8E3EBB1BB3C2D10106371C6BC41E9C18B79E4AC5CD0B52B9D53E0C7D40A5BF50
+ 32731277AE4E45DE44B46B29D94F0049FC2B43B6AFD37A00BCB0F0857B152B9B
+ 627CCCEF26AAFB744C7593DAD888D5546C90CECEA237A180FF6CBA55B7262327
+ 06A09F91309FEC800F739A463BB27C8B5B53CBC5EA727F1EF96B20EE3BE16DA4
+ DE29050F6BA2315A89E0E0C4B4B3E84B632F0FBD675741F5B81CAA27CF56B1F6
+ A46BD3B3C5BE9656ED29426E9A9E27FDA19097AEAF350FB6C501DD8EA6593354
+ C26DD0E9FBF40F7729B4D990A2098097061EAFB302A9C8369FCF2316FAC3D0C4
+ 403302E1522AB906CB1229AECFECAD3958D52B545662457A2538EF2939D54370
+ 4FCAE96D9BB0095E224D32984177F463AE286D121931007D9E1C8D74D14B8F06
+ 94C1F233E02CC2AAB30679FF1189999755D63CFC1C805A290B0C9C43CEF69BD5
+ 5E243023168DF0BADDCD239FFD0BD3EB3BDDB30FB44C6C8AA0C0F08B443B0798
+ FFEDB96FC5C854D9D5E319F16EC7BE250924E445E1E48110E835EFA645D57AEE
+ 009DB8A4C4389FB7F01A43985E00805353D8FFEF94336571A4A69C6A0097C390
+ AFF3A06883A10E1C93C646A1DF0C34C7004B346F8BD896A9E5640E7355A419BB
+ 55377A1765037736E96EE60C71D57C0D3056B524B120F7805D3089F15DE05F05
+ 21B3DD9A89386F0508B6A8095BBC12D5C5B8FC444BF5116E67D349C6ACE3F519
+ A2DFACA1DE2267BC18470EA1547868D9A70CFA10E961C75329202E926BDA8499
+ D3DBD210BE966DB2F86248E2C3CECDF20C37F6FD88D64799523588FF7FF76B87
+ ECB9C772E398AC9C0C04EF74C2CAE5AB760F08568425DD92CE1C4BAD9A723061
+ 494087E8DCFE0EA810B926A5C5FA512206549F5E599314D65935AD9BF7F53918
+ 07A791997071E956E28D69084CEE5B558E6167E14512545705A3EBBFC0957BBA
+ 62C67EEBDB80985E901675BFD4D1953E219FBAEB79031D9E87755D7CBC196241
+ 6358467D9B48642FC93E24806D0BB951D51778D4E26303F1E9A506DFD157D782
+ 3FE9D0CBEE35829440E8FF87BA59CCD16FEC2DF14FB2BC58E175B7A84205407C
+ 28613933FA59E05B449880E0403E01BDD01000C469F2CD1E9653F50D71D070A1
+ 4543FB8CB6250736F31AEBFEE2502EE1FEFDE7812F577C48F475541221B40ED2
+ 3D40BBFE2E2DD70AFA8DB8ACF83356C6875F91C324CE1BF91F01924CD53642B2
+ D4310AC0BA83EB187959E8FF66C24D3E2DA68370457AAD210A49CD91A5C0382F
+ F6DA6E35A33EDE7C07CF260630BEF7BA09BF7F171DFBC8986A4953C1211AEFD7
+ 0B3F1EBF03CEE33E8AEBDBF76AA0B80C2D4F5713C8EB1CCB097736FE5A71F256
+ A4572C27598008F1BB6406DD45ED4C48F7E639EC090E1B28F6AF9E7E17877480
+ 61B4602C8FF8DD90DF6E4EA0311B4C3412B06F8518169B835A63D3398CD82C72
+ 2003E296724D88462CCE301DDAD85F263AF77734B3BC93484AC173F03830062E
+ 31B09C1F22FA309EFF195F3A4EDAFB260286B752C5A5AE56B969290BED8876A5
+ A27251F9EEBB44754B85A625A9B66AC9003AA12FFD79DC1BD3085B943C6DD470
+ A450C0F3DFF4471B174F26140AA29D53A2FC8C4757C11D62B0C3232885925FFE
+ CAC16E2C00B60A66FDE7F4917985E32417F79F60D6CCFA2CE4F7AB18C93C17AB
+ 848429854E499520B11CA7AC9A420E09E0552564D6F287AAD4206D48FC994590
+ DCB39D9792EAC201CF21DA6463BC525F525CAD68572FB7E3B389D79E8CDDEE14
+ 5AEE6DF4E93667997A5397A162F9BB01F4261C235AA85B0A200A3C0A8885BFBB
+ 0AFD6157BB635A6106B1E27A5EB950D1491E4F4164030933F20E79B9F229E56E
+ 0331F7AF9C25F0A2B510AB5CC360B8B15298EDD69AEAF7419F6A4781B0D2BC63
+ 1ADB3A779D0F15F613193C638187660ED5E9BEF4F1217F1BD3FEB44C613BCC4B
+ A2F992F54F00EC0AE7F39C103DF175AA7B506406C2C58160D8E841B608B8E9EB
+ 4BDFBEAEA8C94945199702C7458017B3EA3F13F04315EB376600D791B15F25E7
+ FE6A52F7768EAA149690CAAC149DB82688777F684F8C5CE6DD402964501C3D5A
+ F39960AF5D747777F4B9455005D9483C216068C5BE22C288E6EF036F372D0B1B
+ 96654373AD9A7109B79E306D0FC76EC8A896F2050E9DFECAABAA7E5B5253DBC8
+ 5188A29797E2513E29BF0B27692224953747C8D62A61DF63A0A31FE3F95441EF
+ 4D1C6489F1AFB39EFA97F955525B854B064261E8C777784ECC0F8B631F8F3D8E
+ DBEEA38A659B11D67DBCA6593CDE94F22CE5F8A2F90C9E2007CB246336549573
+ EAB4F2B4BB7318C5EC4E47E88BEB7E21520C9CBCDEC197B37B5F98C7AF9AFA8A
+ 485212088C5E984DCE2BEFE33E5D9EFA50711A7C489B55D9871B81C3AAEBBD4A
+ 822609644B5333ECF2F5F7B11350E566D9B4A9563A50936FC0847CE4560C9E2A
+ 9D228D8713FF37D20F89DC0F339A17F083946D07C878F45657A3FE10382B02BE
+ ABD0BAF50D1B2237BD4D09ADA11FF0BE6D5294384A07F683068E37250BDF6F7E
+ CC01602FC467037E20FB1652318D1356A62208B2FAC0D80283341DF273038448
+ CA4EA93DCB4A513EF48DC8B9B2ED28CA08F2B77E704770E39541B3D8813943A5
+ C38BDCFBB3D0F3C40C5A92AE9B818C73F14D169430A9ED5559CA1A101E1E58F2
+ AB107AFDADAF3083E0B482D15F2433552A53238DC36C31460481D82F23B4EEA9
+ F001D6B03346C335107DD9975A0D599788DBA3244BBC2D33EEC2055F527948BC
+ A2BF8B41B66DD718E8AA22FECC227E35875F11AB3A862B72562B2D6D831B8F04
+ 9FE90EF81D4FD7974FC7AD65BAD156C3780529F36773CC819F3DEDAAEDDC830D
+ EF19EC17D687AC2305CF7C091218C6C66026C807D013CA2CA8381E026D371DAE
+ 3746BA0564D048FD6E0CB7A37C2FD57071B5064A10132E78789902206C99C068
+ 49DFC84FFD5085CC7AD55B093AA054464F5FFEB3E3C3DE0C0200D9C107D68F23
+ C348A943680AFE096EDD25BEC0856692D0BF1193C11F467DC2369A5C80A3AC54
+ 4C132940F7EB7C184F05BD821352CDAD2B428B3E536EFD6FBEFFA46B5CF27F80
+ 9BEE78EE5A471485A31B5DC500727E55A6DA3A095C92981DAC1F5A233A688842
+ 8387983E708A23D6E0105C6CE9F705E87C4E9C0A4B93FE2CB7A82F8A7DF1ECF6
+ BB77CEE5C2754154344605875216647BD8DF9D6D2EBBE9FD1AF21B43DCD4B846
+ 19319AAB845FC7A5F4B27725DEFE4A19E644909764837D592492158606E542CE
+ 1853A925CC38A526AA9EC7E3BD3332A0152FD79A58DC1EDB9D1E54276401FCA5
+ E9A6E94DCC90B53C9DA305526D62143F4863867EBC5EC3C519F782599E2B5E1C
+ 544CAAAE5CB8527B2D8F5A25920D61295149B07E0C176455FF7350C323B075BE
+ 1197E2E8B082DEABCCB92412C0518E35A0794EAAA80C7F9FB146AC2AE2233B11
+ BD67BA5425A084018DA987240DC74E94EAEB78D5BAAC8F253F66C5254B01FE64
+ 199AA69B21F621630DD4AB63C5B08CBA9847E09A248F7D197853D5E489EBEB06
+ 8077B8FD88DED2AE5A32C3D816A04E2FCD1943CCED0B0AA8CA011C6E76216480
+ 146D2E3CC55ACC32B175CA1491FABCA1E66454E2464C64BA4CB386A8387A3511
+ 3EBB714C367EBD4D2C10AFDB2A093FA75D331DA9CE631E4C121C5EE2A539D62D
+ E9FBD1EC8433BD6CE7CBCB8C6965B8003E11922C4859183903BBC146026E4518
+ 2EC39A7F16B195DEA734CDEF8BAE8BE4D745D944CE102E25593ED1CCDD893E0F
+ C7B2554387005B0E820EF7388AE08F84F679716C68F705EAC17F2FDA9F03F69A
+ 1394AFB3F21A058B99F2483996BA7E4666EFA5FDF38525D0DA9AA579806C0FFC
+ A3AF18599C3BDF030390CEC17D95211E7BF3DFF66CA974E8072E18404752180B
+ 193018591467462F0CD38E9496A3DEFE0B57465403D5F7BFDCCAACE20C835A32
+ 75D6C3BAFB6B6205528876017ED68312BB9F2A248E6F1D026AF839CBBC683FD0
+ F58DFC977CF12680A0A8F59E98748A9C83875CDFC66D43ECAE5AFEFF065AC3BF
+ B2E08C9567D5C7F0590E561A7B5152F0918305C3056B6F7FFE1FBFCD2A04498F
+ EDE168393F5B7BD93740666824C012E4E8E724010C61E75307B12B5B43D0BE1D
+ DA0DBE5DE6F6CC81142D67EB0E311D325CD62FF8E4FED7B7F227715DE1B6517D
+ FA021E9994F97ADF6BC54C8F829ABE4742DA6D268C92807B921A7DB9CCA8BE10
+ 78464F032C9932A99DD7B113F35AFFC6A4067E892FE84FA397842390B2034CFF
+ CB2920AE499F75C58B56A8510371692D873AF3807AD794D72C1116F7D7A13A7D
+ D7860D663799AD5825C6173C99105FEAD68D175EB84A2E1D52EB888921B7EECA
+ F576B6E0897FCE44C6EC0B689E86763B603F1CF741B78AA386B1173EB60EB2C8
+ B109FA30AB8F043E9A6F3BAB21054DA7E5F763DE711F4031A082DA3B08E79AC1
+ 270C364F4C09C17E9AE70C2AACDF020835261B5DC3C83B59B240118F99562F20
+ 155B00C0D089E6848ED7205B88767B7C0E139A20215475EA37BA3C5F5358FCC8
+ E489FE1BAC324A08E3891B12BEFAAF723BC5B13AD28854CBA619AAEBE66FA5AD
+ 6130E4D66770A336B69B1E8E0E6E4458EBC1CC599C18B7D75614023D3B6A58A4
+ 907759FA0817A354971F86F392D0370C6A6A218801AD0053535F4FA35EC190E2
+ 0610CF5E35D3E2BE2BFFD8AD9957867EA0599B5932BE89158B7A54F95D6285C3
+ D2EA7554A16625D719041A2161CA207BC99777C46F17A875C0D23FE75FD05034
+ CB1F0FECC6319595C61BE949DDDE3B5C549CF999D5B364AE867A69AB88D74527
+ DAE8E5FF62BD2E83B9BE54213E2733ACBAC3DA0F6E86043D5B85F3797F096556
+ 64ADBB353C26D12D1E9DA7602221445FA6E6E0489D68BA49A2E2F1FB4C4E0AE0
+ 2751E2696E6A900C5A53A85CE24A362F8B3AB8ABD388B1D18A809C5CD3DD9728
+ 42F26B552CDF1EC0B7D41A6F4DBE3A4013EC013B85EF43D7A5716677F17A1873
+ 5CD25196863614C5390A83785511E6E3FECCC6DBA9BABC8589CB1F03B44918A8
+ 88A5F86562FF0280A41EE534D5308FB6888E113FE6466DC737362C8AD8541728
+ 140A4125FE4993530B4BF7E1DED22C18BDFB83FCA456A01FAA79E8277CE304A0
+ 591BFF84D53A802EB46C187D8371966B78A7BA7918633C26EF06FBB939B8B1F1
+ AD8585765566CD9B9C845CCE63F113D1A76324639C8C09DFC27C43DAA084165E
+ A63EEAA6FCEEC98937529C730F2C51E3E1D03BCA6D5233E9BAB7B79132A4EF50
+ 7ED5A618418C829BF4FD83EBE78140E394CB9C78596FE80E1386B7FFBE8AED43
+ 54DF76C4BC45E64CB5CC9E90169853B0FC8B979A97B4D357BFECD90B61562213
+ 133A876E6645B4B9FA8FD592719BFA9921475C1C552263A7F3AC0C81D6FFED5C
+ F4C513AC4E61783C81D5B1C17B878281746A0C92C877B193A67BDAF34409E9F5
+ 57FCC55C1490939D9BEE07158CBAA67526E00981FC312D57460443DDC2FC4117
+ 0A0B5A03C5D2380C9CAF17683D6C31174E7ED28A702ECC75F9D223E338CBA5E7
+ 8459B891E5B059D9BA06EB6042513D05505F8A81170CC870389305B2A864463B
+ 01AAFD1F466EBB685937E7C0AB935510C07D401738F1C4C44BC1D875D168FC21
+ B814699498F95C7C08DEFEBB73814EBCA1EE8DD9401486B4B4DFDDEC5AE3D000
+ 4B0E4FFC01D7F0ED874708F31066D4F3F46FF8637664D256D888B1C708CD27C1
+ 8888427201D59028AB6490B1E035D59DE25E1B59B96B7DD4570BA7F7E2CD37D8
+ C7AE3C51D0FC84A147C821BCE147053578ACA41C9873212344709DF2D4CB97F8
+ D1C598DFB2950CCC6A008C1022E32C491E18C977A277CA6118ECB8698BFBED2A
+ 73EDE1588D600AC2F583EFC1B5EE1BAE0E9EF74306A6B7E2DB59572A4429EB60
+ 22CEAE58FEBEADE1E6450E913E9662FEFB439BED85D6B764D34333DF1DD838FB
+ 9207D5C7D20F3B676D839DC41A8A937CAAC94BFD3D1B7C4EE0F6BE77FB0FBF32
+ 204C6698034756071D626D931CFC587C60CD4C8DC961556BBA68BD164D7D0B07
+ 19A24FC051CE644A7F0EF863BF85EB3F7FC2D0FBDB38AE4F276D5DCB818DACC5
+ 15ABA3B601E98B990F5972CE49DAB30DB2AB01469AC12B37FA2CC625CDEECFEB
+ E090948D9390E0EB09FECD350F4860E687A102FBEAACD86FE68905C240627934
+ 7A8FE8B2537A4A8FD18AAE05929644D1C14E53F9CBBAA505823D5AFBE7A876A0
+ 803B5547F59FD5E23514F3CC9BACB56A2522438032929DBA481CDA1CC876A7D8
+ FED4DF9285407F909F9427AE35EA5E1CCA17D12D47DAE264143FCB2D76A259B8
+ B7D976CA847D5BC36FEAC76CE9E7BB836E7595D6A5EDC2DF9B1C615B31B2E24B
+ 8186BA797EB0163905634F5FF389F2B05000DFD2E8EBA41D9B9579B07B3003D7
+ 511A550BDCAB16CCCC906B922AD37D6F75D21CBFBD76D113CC66A85B0A960EBC
+ E53D159E07FF13148526CCC84EBFAADC1B06CC3617BED81EF82B49B74B5FB6AF
+ DB60925F46749DC1EB09473BA6AAEDEC4385883704EED40B0D127BCD3C0681C9
+ 50E4281B8B4184D3E7274B6CA8CEC7D6E60D63EAC65F633B815C19C59A068CF5
+ 4A868533CED85D7708ED36B465054C9567D111B8D94A4D120427526A0651850D
+ 14EDE9BBAB7BE26900BC4FBDFB591977EF9AAEEDC0935E28509392EFE3B76E38
+ CE69D21C4221DF871E912798BC25F00F114837836BDBB6D0CBC9415A0623D7C7
+ FDC8314B9A8EBADF3381AA6D19380814E93FB5B8D65A8BE80D7B61E881581309
+ 04C3B83839347775FB4B15E5588E21FEDCBB8990AE07AD18FE1E8F28B8C1B8FF
+ 0BB3040E4B2E66EFB4A2A8FF18D16B8E6DB2C3BCC4E22A0BAD8A6D96CA1F96FF
+ 5E520B04928461FF0DDC6DB3EB35D51B98665528BD7CFF66EA6B44A31DB050F9
+ D5785D7BD6DE9EF8EA3A7ACB3FCF4EF299323CB9F606C3C4838609206B12C20F
+ 94A2A2552204326752BC57EF9F049C8EE4510EFB2EB8321CC9019ACC50ECF9DB
+ 6419C1C3832824692A49994AEB7BB433A07E228E39668B49DC3268B9C1DD5897
+ 95B9A5DFA3A0BBB2D1184D40B2EA9EF01FA265CBA07926435A5688C8A4BF40A7
+ AD41087441B8A82E297B6DF4CE944E3CE749C01B1C5E1FB12AC57B8E6A42CA9E
+ 169DE13E085A35C58CA9AE4763108C9FF32713D0343442D979B8D388297CB85A
+ 3E1345CA90B597774BBFA45509A1D07174556827F5E47C02E9242953FD49C3AB
+ 6118F1B4080400B65885BFE41A036D03BF3CCD0E9AC3F7A70688C4A589871D6F
+ DD520D7A468A7F0121DE9BB92C183638C427282CAE64E4B129F47ABB92E4688F
+ 42672F7AA273FF37E4325924BF3365E30F262891FBE1644237D30050E210A65E
+ 66F8BEBE700AB3FF67F5A04E0651062397898BD14429A2C9BCE5A127B8F2D6F4
+ CCEAD1285FC56B0D1F47B6E082D08A9DBA0BC4FB404EB72768252C66F75E2B33
+ 1CA51BFA144A35D2F6CF7C085FE217D036D2ADEAE03C09F60A16F913265C7068
+ BAAD6FBDD56063AE23AB03F5F0BBFE7F7E3A1A73E35AC5B05BC012241701C847
+ 0FEFB7001DA36393DA87694DAA7ADB348F32AEDB1FE3A25D9A299295BC3B0F66
+ ED5E37505527B179CA5052DF22544D3F56E89D4C329B8A7D63BDC0DB30728D9F
+ 956AF04429C24BBD96D948F6E0C22AF3980F2AFFAD52BC052DC31E9B1C7F2B11
+ DF8011ABBCFB82F26A0DE6FB6C068FBD8BB8391FA1885289C512AC92C8F84CCF
+ E85B23ABF35266ECC18F69F13DA82A04E83A6D063F3700C982F04497A7DFA6E5
+ A0998C13630FC1358EAFA81F90A91C2D4B14391C9892AFC0B3DFA6D8C392B8D6
+ A8490A845003069A6372ADCB013793AE6A9DEF4440E28C88FDCC3B7A8013954D
+ 74B07F3374EEFE4C7AE3CF4A07EC9E2BFA1E136EA8FEBBC297E86A4BAA5CCE69
+ 38A5994955999AC6A171EB9AA355B37F2754F9E9E911FCCE3CE93DB0AD719018
+ 5C0162507374FBBBB58569E08317FBB86FEA59C5A289117ACFACF8C465EC60F1
+ CF7A36AAAAE368B2DAC13395EED48B74F6BFE51D4E936FEB664D1BA6EA06EB6C
+ F80B8D470040DF844C1DD582ADA84A6B9B4CE97281ADAFB336AACA40FE750166
+ D749E635D1B9C9477B97CABEEED0A41FC113D6CBD1F0CA8376AAFC2B0EA7218B
+ E039B66F7C75A22F34C687D6B2BA3BE09291782BB506BC7C6921A6C5798506B1
+ 682B3B3F27A6D6C5756EBE2E628F05583FE4F0302EB2C42E25C408D525B12CC4
+ 4465FA0CE523F8816A59C224B78E48B84A03AEFE16FD89A8120026C0A82F544D
+ B43B293DF967B48E49977CC44A59130052C128CA5CB83B94192832792F8ADA8D
+ 1580CB84F5E14CB4AD6BDA11E670FF6675EAC338670CB95DC37776F4596C1FD4
+ 3B1D5BBFB6A6DD25E6E199069C1EE0A8ECCF8D8407FABE65121AB505BFF33379
+ ABD0BB84081C57D24B81A90D63830A398A441B0A53009E1830670591DB065DC4
+ 87D7324A5E15E6501FE28AE3860C899678C625D565D8E08407C14ED4CE545E21
+ 1422C926DDCC42739E97072E042C79515699A017F9F2FE243C8A6C00036AEDC8
+ 5E5DE474643BAEDCB3E7F0CC1FEEE7AFB54BE6AE3FF09B6535F43896C49F7605
+ 896B2C07A041B648E85C11AE5C34FFB18486B932261567F4AA7383046E1E1D82
+ E9DCF5976013AA21ABEDF1A15FD456662B05F5A1577D4493A7DF05F345BE643A
+ 3FC686FC81D8BDA0DBC0A47E4DC28F63492F240512EB5ABE1E6A008D819A01F0
+ 705599F5BC126CFE633902DD38F4731FC7979B17920061DE80322B6BD5DE33C2
+ FA7791B25A4A217061D1AE82DE3ED2D3AEDE32AEA047E61BC98EDAA83F114CF5
+ 52BC102A9B2D1A0E3C23EA5AE8B33CA3FB934492F743910EA3BFCAFB86A426C7
+ FCCF9789BB484219FC446DF666888CA6A39CCC3C76C2E86ABACC636F2A93A544
+ EA0F9180FA8D61DAA0EE40A6E406D09CBB70C53570B2F6F3C4CD64698D7CB7BF
+ BC3EF0CED948BF6D40A5BCA3627295A4938A06AA6A6C4B4826B088C6AFE9813B
+ 908288C3981A180C01AA4BB4E4B53BEBFC9D1EADDB15A7F22D7CEFFE39834139
+ 0E97C6481D8C5D8E1EE151485EB2C8A093DA048AFC4BA0F50277FC4754FC80F4
+ C242A78ED01B84EFC96FE66DB74F549844D734BA2C7EBDE04FE5A2C64D21B9AC
+ F5361E7881AC69326C7122772586D9383F64A72D29DC3356115A8CEC7F5BDADA
+ CB9B22B86CAAC855741C5ECFB8E3BEB6F0670435179B555B79A92B4547F1BBB4
+ E3B69DAC252258B728EF0A8A9B39BEE68BEE485812F04935BCFDECB1B909944E
+ 8CCE204328C8200A370FB2F359FC6B9D1F0D06DC2A8F14AD45EC3762DF2E2EDD
+ F63BEC66F5869703ED6936478D96EC9E0269DE45B8F2E99F87860F89008502D8
+ 203335B09578E54B53A21E740E6542D8D1AB249C604162092DE5545A6EF88A84
+ 4C428BA5A6A139A646A30F5F7DCB31C775BC887DE2E457FD588556865A4FE3C0
+ 61EE5249753F78CAEE9C1340829A8AF9D34907E1C4C8D2BE7FC725AFC8B42C6A
+ 657EB06225F79FB20039446213A69C1242BF1A7B35AFE0C35DD40B3E4AD862DB
+ F3ACDD0B9AF0A59C5143645BC27377655173BE40D2C7B014213A42B474848AC8
+ C23AF3BD691E55950419BA59DBAF6BF29FC036F3556394DBD7BDB696A2454286
+ D02F7B555226B1DC70B7D72FD879520543ED150191D9798F2CBA452502F31956
+ C7AA753BF21599B74DD82D624B88D84DBCC8A7D3F91A813B5076000A7DF5D3E5
+ EB77A6E06FAE868AA4280B1B1A0C4B3203BD0DF7FD88C1664AB641994BE45876
+ 47E660E536A31ACFFF09B34AE9273C9B293F419AEEEF11A62DB7AFD4F7D71ED1
+ A9884970C32574AFE26C7BA8F3070ADACF283F608F474630FE014EBFA033F887
+ DA3F6C89609A8F7409C6B680D527D685701F60D976BF862323811D1A4CF161F7
+ 0E6DE1413D5F545EC22423D7EA52499DF32C6DF48742F6906C92D463E17C60FA
+ 01D327A42623B9F34A434784937C0ADD9FBCAFC8FB3954FA9288C3A76F93A252
+ 45546611583103029C260D91FB1A2FE998564377BFA89798AE7FC04FDF97DAA8
+ B93D2BE4943966F7DE345ABB559B1B2A35887551F7E8CBEB707EC5A754EA47C5
+ 5AD10776296CA778A8E32718AE589D8F5CE647C641D47797E30F450E4F7CB5AB
+ A259E85F35C3F50232AE4C017AC89465CCEABFA3655EAE05DFFA5D4EDEA28907
+ BB617204E046B46D4762FD952AAD26BDEB6A5B093D1276EC35C0F4FD1B251375
+ 8640DAC68FEA8131328E050152CA28E48DB4AB2BB7404AF535CC015123ABC74E
+ EFD4D396CDDB63E8DDEA4C85CC4D64C6E2F4097713028219209354ECF772DA64
+ 228FAA15D348527D1347B4E3DDF9C339D52AF736B4CAA3EE11A4A3C935CA480C
+ 707A4B0633292DB5DECEFE6C522D3D22C583F035C2E762E9D7FF55EFDF138CD0
+ C7FD770A2C0EA24B7193EAD64304B1693F01E67FD3C7594BE11253103C989C5E
+ BC7CE52CB42BB459D1E537041AC19B0C39503A86D0E3599BFB2646288BCF0928
+ B91C5C1879A6C0D29CBCAF3A3D669A1CC3AA067FB85423EE79269A7CE602F051
+ D65A23F0C82E353A749893E14434826AC4BCE854E139B01EA8D5260D591B6C03
+ 7898C63C84B8349309A8D17D446631838E19C8611F094B8B0C0DEF663D268109
+ F1358C2F96129308C61323396DBA9E6C4920BC83592D2199A8BAA37B03A8A3B5
+ FA7C59C28A1967B81C25694D8CB0A659B6FBCEC8CA9780C0958368418D13F184
+ 70D219D5A3DA306C32009DC98923F9E01B56A8112433F8A730D828D13F426D56
+ 72506705F2619A2AAE07B32845B3573257DFB7B79773BDAACCF59B7F20AC78A2
+ E7B03D8D673835B00402B47DD2235C64320D331EA630C90E0DC7EDE0C8698C8C
+ 98C66BFC927B5802242CD4F09FB02FC564841EE3932855404E7E935AD5F17F97
+ 3BD3D41066044977CB1C20274229DB7CF80E3FA1B6E108A90063D221461FFD57
+ 5B3B3BA5B512594785FDE003D20009122B1E64FE52B3F6A28D48DE4843416237
+ 5A6AB7C5F7AC83E96C4AC98F2950A92C2B544B9459768DE5E79E1E448D55DD73
+ 34D66F2F5BEC07AD03A6EDA160B841D6C0F358B1917181762722F0C23D3DB4F4
+ EA1BB3499F2054ECFE42073A97CA33EBF46CF5AF4DFCD7AB7B73531D24EADC3C
+ 1A63052219CB6026947A802846DEA171B0416EF0267093F7F3DB188874D5D4CB
+ 377906B8098AFD89153AA32EE7121DDBED552CA3A7193D981F7C64767B4E1048
+ C8AE7DBED93217A1DBDEF8389B05DC846D75ACE44D775FBDC55B293DDC5266AF
+ 052038F71F7B6493ED3651AE935CFFA42A64059C268C39E57BB3B76882440E3E
+ 6AF1C73BF041697F1BBE3FA8DB86F84D17AC1F262520535B0224496A169678AE
+ 1F96994B837A31AA08201AB23A179ECB2E2501CCAA90F4FC70ED2CFDADC4FF98
+ 1DE1FA214EF976148CE2AF35792AE989B324BBAB0CE3F4FB4E3AD64453BFBE37
+ 8FEFCCE2AB1348A0813D6FC0FDC59D3C0F9DA242BAC25427A0E3538BDD963851
+ 5EE3C7A036D35DFAA4EBE8B69BA41C4A7CBDEA38C80C99C6941129AF701DE217
+ E71C9DD44B755A5C5A870B5F3BC627DE88BC0930CC43FEE06F5B8ED94BF96999
+ 1C738A1B54EB0C8956C094CF97C06BBB9D32A85562D418F2517688CA195B97A4
+ 3158E147041AA0B82260B19FBC56F7A826B1383264D5A7BDF4EA53D73CFEBE15
+ F3265E68C5C8CD1CA201FB575D26C97D49A8BF97555D77036B8C92B0425AF92F
+ 78DEE4DBC6B8FC443CF11236BC803BF44818C6BF0834E7B8EC20B2A3E43F8799
+ 9CBED36088D3A0CC5E1D5E7472F071C8B6E02864E17704DEF7115710C4CD8A84
+ 583F80AAC6E057399DC64C260E7DE9A051EB7849B1F8EB376AD648C9EBA4553F
+ 108FEA93D0ADC85D0DF63F961833C9A611FE511EDEABC7B454A45F08D246D675
+ B8A7626F5DDD3EFBB2409119A1FEC085A9A174B162144E4A2AB63E0303F84DBB
+ 71FFCC882C3F077A21B77ACBF1EFACDB226D658DE6D50AFBD041940D4C0F4360
+ B325A35FD35D47A8E0F821A253E9E54A30D78B457811E4FFFB32E61FBEAE8B0F
+ CEA93FBF11E3AD90B01336F1C0FD86A0716F76A10C05D190465802799CF57370
+ 68C8892DA1685A33BECCE5B82ADCF13466310B1BD0638180B805CDF488EAB185
+ B427A5351F77DCE78B3A89010FB846DFB6315B00185335459C1D9578457F8931
+ 21F3C90914A9C3A5A81F4EC0766467D5AD705AD9F892A3A35DEC5BBC768BD2F7
+ D2AC7FEB16D0BF28F5B50887A75097C01869B098DB10279F6A30B858B8966D9A
+ 1316205BDEE19988299085488F02113EB16F5C92BB53A43C595CE7D79F577019
+ A2E6673D6C954535E3082E2C340560092CA798E6BEB039237977FC1B373CE37F
+ FBE2A745F31A88BDBC39AE7E127DC24EF6A7F10FD1BE7D5DE98BCB27D5B7D750
+ 0575921F2431C812C55555329D40979F8AEE390D993706880969A05D3C7CE281
+ D398E688E709F4E79899C5D29218EBB70ED0762A50E3D5DE9312DCA582B983A5
+ 3EC018A68348B4D80138D48C6C0A2180AA5BEADD221667F22C15B50A0ED9084D
+ 1FDA8D664A80237A02CD95679D801196C26F40C6E774BBEB3478D17B225DD294
+ E7E2077D4AA249A72C487DDCD2557BF04BEEB146D08823A2C60FD1FD6D62890B
+ B71E701BA187E77B68461B7101FA2473F084FB18A66391CE9C57997E8BC8BB43
+ 778AAEB595073EF7CAEA5776F125D1ACD2A85D23EFC09D5220493925D3F8E137
+ 92FF2749455984FB717BEAFB01F7D47C09DF06BDE7725EE7E73B1DDB1AA9DC8B
+ 2B5EAA574B7C0836B962530462014B011148C46954793FA0666873D678F92893
+ EE48F02261EFFC6B32A35813CF9E07AA42932386B1AC7B8FBBC7D8F55951B76F
+ 3446DADE6FA80C4D6D4BF8E39D16ACA390B93A989A5BC7CE24922B31718D473F
+ 08B6E198B7CAB1E701FD8C33A5EC55BDA065093E2B3CA67294F76947261097F5
+ DBE24D00BA409FD3AE294B6E43BF6FB4E2EAA2455BF23829DC5F34AFD27D9653
+ 4774E3F7BE1A65A73811BECC88096CDC57459559FBBFE9DCBCB98854555DE680
+ C8EE3ADA0862501CE30859B60C53E48FCF96B676E613ACC476C83146EFB5CC7C
+ 8B7DC5B1E0C1FD96E470D7EE88897F5AF93D8224A2DD60C04104019EF5FC5E6E
+ 03348E803B1FA6BDBC976830D3575C64129ED23594181C52054B275CBC7536F6
+ 82FF1BC58BA90257769E1C5FC8EE2D2771B9BC1138B6C4DAE4A75C7AD2926177
+ 39A08BA53DC515C681727BF7BE12C28D967CD32E03BDBBA4F44A8D6E0DCD8A0D
+ 8F97B99B211CB1E0E97D3C57055F0024B6577A84C9662284435835D1CCCA7AF4
+ E824394FB95BB209CF73165528C937BC2374CCCC4151679CFABEB49B67D33297
+ C40C16E101EB3F85C48015327A2C6EA37098DA88B1DD9FF83A243C25C8EDE8A2
+ 55A8BDC4A0FE26B2050FAE078623076576725AD79DE53FC7E193CD4CC25F572C
+ 677D8545CFA1CE2A45A6AC7D9D84D29A1D4D36F3A3EDEF29FE3D1AF0AB9B08D3
+ 1832FC91864A2622F671E24EB6D1BCEC167D526FCB9415B11C02A0ED53546203
+ C0B91F2194B65AD7EC42286CB55E629C2B4325EC3E1B03B933746E87C6AAA8D2
+ A236EBB1E3DEA4D0C7916512C3FD85B66A15E7A5007D41A38ADADDA005045811
+ EB6C5F6718542A3F07F58B9181CF588FD7519A97A4F82A7CCACDC651E0E384C1
+ 2C482E8D102090B8B6F08489760DC16D255EFCD4021E9D4469F1ABF4E22777F8
+ 6A84AFC1BB5BE419FAADBB09B7199DE8A7B6CBD847C546B4C12F09B5DEC76ABF
+ 66DFBEE8BCBF06DF426A51CDE6B3D1ACCFF21AA74F86266D68D2118B7BE6AF82
+ F0B4F34A0DDA2C24304CFEA8B8625D2EDC88A1443068246094B5ABCBD920A555
+ AE84932E5890D279A1620816DF93F90861AD7BAB512894E79F448AE257240D48
+ 4073A989F3E7A5E47000BAB9D110B729718071633598DEE9CB5626A16D86B01B
+ 69DC1F0FC65803625641302EA465474CD6A8BD3BFFBE8F5DF1E6F621772B8821
+ 9527A580D851F928ACC68611FAF07537CDAEE5C4B873228B3F7FF9A5D5B27C9C
+ 3242FFF483B22F0E9A91B28EF510D6C43B44368B045F82AF51AC5B4DEDFFD2CF
+ 83D11845F9BE01D8D674604F4817C052D24AC144ADE73DE38EFE4CE18B2523E8
+ AEA44A9A67664670759E7309D151712EBEEF34B8E6AD0D3FBBC1E3A123250C0B
+ 3432FD3286FD73271BF9D06697DF83D47F668EDED8BCF7ABB75F8C5BB1A7A952
+ 03A6F7C9CB28E16446101F6821303DE30464D487CF910F7AD6E4F069066CC5D5
+ 52E92EC71778BEE3277FB06C276603881863B6A45917BF0C3D01CCDEE979271D
+ 4BC5DCDE1ED77B6CFD10B955CA323A2A0DA653DC555611BE70A2CF957B8A6B71
+ D62811E72BA36E62B662B7F1AFFDD095571EC219BF958F15090E04CD3BA3B363
+ B2AD03F96BAFE50B08149ED160C93D4BB4ABC4D6CBCC2DB3DBF5F722AFB0A4E0
+ B0F848D84BF3AAABEBBEA242F55289DAE74B737BF44EC36FC0DB048AEE16340F
+ 3EF5E4036F97FED3C3AB6570C35F29F02543C698E435940C1A875B2DA1CACC8E
+ BC7E129A064B9C635D3CB53F4D58F1D5F45730711CA674CFEE78C81C4C678361
+ 38466390D68D95790FE5B649B9DCE81E6FFB0DD98572C0307F3B8B1BC44E5421
+ 1C86951AF399BC548D9DACE3C73BED3611B329FABCA71A7E1144C8AA7DF4A245
+ E12F91B59AD3C804DF16BB2D3C381D74CADBF95729558D67F515F115B5960B00
+ 326054BAD2A2601692EE035D205B0CC090589DA989B05EC6F7A7593F5F57C104
+ 208B9915CA57FE4B322FF8FDD9A5968DE6D47D19344018509B099FD5D167BE4E
+ A7BDFD7C4E6BF62683EB1AA0739ECBE98D53A6EA6170223866672A355360D2FB
+ 506CA0E86AD5670F74E141DCBF5086970B5AE41839929E6BA0D768C3D1534F94
+ E8E88A677542AF25504C0B22F12CBD7B4BF7590182BE110DEFAF524F3ACE5546
+ 1258FB664ADF938F6469AD3DB449E826999382D34E0DEC20D2AF8D9D421027A2
+ 73AFFDAA6A0BB620CD609785AF797646B1FEA7E947760D461DD599448B340F75
+ 4851DA69F07334D933E284C0E283AA0CFC7DDC906A889B52B882BA4B1AE46428
+ 3A58A803F2D435C00EC899B9ED8E506ABC4EE38B17BB8CF5D9814331F77F294F
+ ABCD5A1561CA9BF448691FBD3D2807C4E083B7B7A8AD21CEBB234B9305B90E64
+ FE425F97D3BC3194D1B65AC24E191869C583FE57EC79E1592D7836A47F3E92EA
+ 09B0F0458986D1A1DE2995064C7F82BC125AADF4A93B21E409B646D818BE4AFE
+ 77B04B9AC3885ADCFCB341DCCE6DF0636B6BBF58C1BC34289377413E9E8CF3CC
+ F7CC9864327C0CB25A04F98A286EF1F1FC14AB3A19B93B6AD743F11CC5FC4A31
+ A8EFD5587BF332F82E04CDF263E07A87CAF576C8C7149F335F151642182F7808
+ DC6D60098B5F2DFEB6FA00118EB4008C3487A36625B66C2AC14EBA860050597E
+ C997A791DAD3FD736AA10690C955DFC948454116D92E594F1A30F7B150AB8209
+ E6E19F4BBF8544CE934106724302077167F50A371235866A951E8F363A6644E2
+ 36B00B1487943B73EC7E5FF60460615A8E9853855160F9ABAAF8F9C1038EFE86
+ FDE70B73F5270CEFBB285A775721221179BEA6E53CA944E23EB867B825B15959
+ 30DE78DA48E383C4E9C4C5DA8F30BB73D11C51B0BBC5C76F8B1B1D93D5AE0F32
+ BD244F093B39BCE035434E0440428029B8B5F0AFD4D41E9E34F523861AF81EC9
+ ED2708FB5B1AA9D420CCC6E3361EAFA2F333B44D6F526033F3D880C5EAC82D1A
+ 65793614FCA7CF3958B6210B81366E5BE43ECEB8446A3299FC4A182DE1934228
+ 1258C062F3A2BE78FB1BC9F3FD8844EC13B1E06A2AA5363B9F805905435C5D28
+ F891ECDE4A233CB9A408E31038AA2A70966872891835A0C6633D202049174816
+ 48B6AEA30B731490B902878755DD77FB704316C5B8DA3DD890084B05C5523E1A
+ 33A320484E810B00ED58837A96BB2DB7F0208E1FB39CF6E847B989D806580D2A
+ 321192E8017527D5AB6169EC2FD30E00EAA2E8B1F10C4FCD6CA60A6E82189E7B
+ E170C3FFDFF9632EA098310D7C39A99328E9B05AF8A5DAE71BFC0107F5E700F5
+ 58AFF2F8CBF2A26EA6AD4101328220FB6F47FE75AD7B2652B42AEC88751F46AE
+ 16F17B7946A70C085638E3737F6609A0AFF018CEB1A0EC78902748BAEB8C3B7C
+ AEB9211E65BFCB8BBD13B27A0014B76C037A93A15150567F9B2E72F2101D6985
+ ED911E7E7AF885D158512777193599F229585C9B1A8F82237C8019A32F0085B4
+ 087F495FC096524B96A2B614457D97BAA0320850C5D889E693941C4F1AC98223
+ E21330B9A54AE3E106574722A4D7F78B34B7C8F64D28B1E5946FECAE37CBC32F
+ AFFDA4D200B4B7545E68D645B513BC1FC8D3E033964339BAD419572A4FBDB9B3
+ 85796C49C828CE74497D0484A165CF00853AF724941958BF652CD4CE9999F8E6
+ 0DC120FD23E3AB8A04C6C38926FD48BA94DDB74D6A09CF097A1DC17A434FE38E
+ 687567F6CB6ABDFDC4587D8AF5EDD3B8C86B1A988EA7112D576FE3D97CC69A5D
+ 5B62BD38770296A35BA507B19D9DE4E77EE2D207EEE47D96995955B02C856C80
+ CDD4D9BD44C822B068B56D6C9FA1BA84B02BD7C802A96B133702EFA6DD9384A7
+ AEAAD9CDF154B6A9E2132155A7ABEC40AE67EB9CA77426EAED575DE34E95566D
+ EC70CDA670F07D80FC37C80A5DB0ED07394463F003ED8CDABC0E053A9C550DC7
+ A613AFD3CB3B518EC5806BC6C334087A16B64C0DEF692BDAFB6C2C38E76A691B
+ 101E696F219ABD31A1E4F2EB79F73ABE31E17ECFE1F2AD452E3D29472A5DA8DC
+ 2DAF7EC85F0347B4257B24633B9985D9EA22FFF2F92341DA277F2DBA0895E6E4
+ FABD78EB1BE576D1E86BD85DBC53A8608EF3B4AACC23D8D0579C3543226FBA0D
+ 1D8B30B3C3DD88F04227EB0F4DDE26C9F50197A790A72FAA5DF8E3273F3A3DC7
+ 9D9609C06672AB4F5EF51C18D8DEF803A78106EF4A12AEC482201E951FBDDF29
+ 310B562764A41A677F4F6D1F5EE4091D886B7931A4E5CCFB87125934D92C08C8
+ 2DA6AD072DBCDD6F87B912CB8FD07FB76513DBEC30572F5277A010E917EB00AE
+ B2C77D298F465B4AB9ADA2869567FBE83682AB57A7D447A1AAEFDD66CD2901CD
+ 742C56D8522315EBBC65310990A77CF2362587B91110736208E87516F07215EE
+ 64FB1CCE61A5B4D8B8D79EEBEFC27281BB7DE2A2337EC576CE9CAE471393CB0F
+ 1351246B53A619923BDF824BC725F274B5B52D2F67F3F4876C59C8A0A5103BF2
+ 1DCBA235E7F2DF78B54D3581E515905ED3977F8C81FEBC482C16740A0D400C40
+ 9CDB39FDAEC60198CBC7D4A854A3C3EB5346B76D72BF1D3A9047D658F59C3AB3
+ A0D8AFD9E30A0BC5D32901C1D66B1FE95A39E76BAC44DC846772858CF34210AF
+ C0B7A490DDC148C30487EEDE8DC60ECE409D946E53CC99A4D994224525060D07
+ C3C6FA4A2AAE7A241D68EF6B5BC031CC12CCF01F344178F329CECD6330FA0023
+ EBBF662D24F2DB2CB926F76BA1F31BDCCCCD3F2911DD7E4A9C9E1A1589AB3B71
+ C9370F3130B6BD0FCDE4429A6AAF8A8FB84695C30E1178CD620D6C8E47D7E881
+ E278AE30DA62822B3DAAEE7504B3A57A75A41E888B4FDF53018709EAB1ADBA2C
+ 28C4686F653BB9BD36321030370A91405D2388C4B1A3952127157FB5CE0DEE71
+ 185DA3776680E481CBFA713E5FD39DD716A8816C990F74D2F7796DC5A5ABFFCC
+ 10EC0789F25F5E08313DD349994CAAD6118DBBB5AC9E7C08FA1CF84E39A4D2ED
+ 5FD652E0F8226DD41BB8259341ED6A6099EAE2E35CDA2EFF8931CDB0FFC6B04F
+ D3AF6DCD26201B3A93D15AEFD15EE8C4D54A7B63E2BBEB63467B3CDC2126AF84
+ 409AFE83666FD198CD3DBB6DE925D52DC8C04A7FEB0C50B98D82F30AF988A610
+ FB751A693B8D24D6C9E44585FA08FDF5C14FC062BFDD0F41981825A6A3CAB34F
+ 7D49F3E78FD741D5E8EA44DEF5C39421AA20D9E4410694CE0C935FEFF50BFF83
+ D60023DAF2740A1B1AE6BB608A285F095E80926F934A50B2BA3EBAE4CF608382
+ C4D80C2714BAF2D1C9EBD14D2B3EB74BFAC27B3D0E763582F9289E4E96685045
+ D75E75C26E278B7D68097DDB5A5ADC9822A02A2AABF4B2621129A80F204A0AD2
+ 5E230884649DFA59D884FAA9D19B1DC207CC681A74C4785CA0C6CE45ED5E0691
+ E85B9EC6717E61C57FD35208FC5E26579CF852CF268A20314151647FEDA42A1C
+ 4FFDD26656CE07A42C21D591576C32367048C68909B787EEDA0B9E334FA306B6
+ B5B8C9B51DA1A6DF01E352130FB63AC35A9E9097541035CBCB330941F778126C
+ 7CB7F31E986A65F32AFB18DE6E1C28D47B01FF0B2857B8F55933D71641EAEBCE
+ AA6793BD2DD9B137E160CB7909885A25A9A62BD463566DFEC5B04DD9D79FEC0A
+ 03810664D7D9CB58BFB7EA72EBFAA8F77B9E78457A4016A408A2DD05F933153A
+ 78E879F6B171C199707A90AF68DECDDBCBC24887A936334AAC60541A71F39C38
+ 85EAA93BBEA067823ADC4FED17FFDC889343AF95E399E729F33CCE7CD522B6DF
+ EC650F2EB5060DDB0439497C6B9BFE9E05DC05C0C059B3DDB04DC02550F9D17F
+ 8BC1C4DB73FF740E095239EE7D76CFC550D8F0EB41795896EABD316AAB3718A5
+ 3A3A9666ECFEAECBA15AD3B09DF84C40629F4D15A7ADE7FBF2B0FFD35813DD2D
+ 4A80C67101B8EE1183690A20B40A006649E25EAE979F127C943C96F474439B22
+ 140FE9D71E4070F9617F5D823A4C4990C20F48D320849744E92E5EFB1AC11876
+ A8EC438A2278923D3A24D222D929C3DBAF42F97CC8580E352BF87D33B4B706E0
+ 1B76BB81E93BB9FB512E2862D989055E3900AFC9F2BF1B4E8BCE6EBECE772394
+ D88845B73C1DFBBD8B3FF55CD3775733D9AF2000BA9C7BA055425175D6349935
+ 516D7DA2DBA58D4002EAA4EFBDC04AC4240BA17DE028041A4C7E20E92FA17735
+ 492C59E8BA1FFEBC74BAA221A341C985775E6A6CEFF39EE467ABD89817558176
+ 721A6834CB85BC3FD4DC941A6CEF7CE64D5F335F9A2ABA8F97EACBEB04901470
+ 1996709FC285F4BEFA7F77C28C552CE7EF3939FF48C03A86FD47601973F39D1D
+ A2C328BF17E4CA7D190877F32841606898EC631CE36D83FEB60E77ECA67E13A8
+ 31DA7CA14F7C0CDAF6CBDAC67EE2FBB9551F0C89146A98945670D387D0591A07
+ DA1982459C12577989635A2F646ABA8A31954E45E33819D4AC99C804EB8B11C3
+ 99DBEE6EE82805CE9BFE79E9B662D0C4A33F2BAA4C109F3DC2F7CECDD8C8243D
+ D308F853FB599C829500A859FFEF179E4C2BD700558C66429995D84560FD1AD2
+ 5F56EF2DCA61C1BE3B386433FB469B5A0A1B900A2FC81D9FB06BCC2FCEB463EC
+ 3C03B2F825F189390149D2CC83A897F178FD125AD1446641854014B50532B4A9
+ 2BD1D8F7BAE53125B4335D52CE2C0598FF18CFF00A0976BC12613086F136F50C
+ 7D131F5A5A31CE4C95F1CA44C5EFEFA2FE51A664F6119CA78DA3D5478E6E4E40
+ C3F13519E57A34D3644C27FA8DB1972E6E86BFCCF0EE0D98AA0338AC8B30CA82
+ 8A1D33A86B6522D8193BD3FB8E8D18647EECF2A4FD16CC304D7B0EC8D9DA7127
+ C4DA4E6AD09FD7CBF1014F2D1227E7B7DB812E489F825ECDD443FF007060A40F
+ 0F4FA005E1D8A267F88BC1E07D4BC9DD7221D8830DFCFEEBFC6B35B95FBDF79F
+ C06C3D4E8905888615DC442D58461675F6C88BB2D8EE590F14D9E0338A9BF451
+ 63A6691CE1E964536340B15EBAA8D5D17FC471A3FF926723327593A669C41D4C
+ E6AF278ECD95A009FE18CE6A1E1AB089C844EC46E09CE45AE24D54EE06974A25
+ 3DA746DA249C2234588CF1EE878230685DB94916E7B43CFB4B85EDD8FB81D57E
+ 5178E21396D8B1D344AFEDCE6E9A3136A43098EDAE40044687AECCBAF625B235
+ 908AE72B7C3CF38A6E44B20097F10A423A9DF6D6A4B559AB2148B61646EB0F39
+ 2B696B036A296BDD70289EA235EBD077138211D47D5A39CE0333890AFFFD16FA
+ F48647FE575250EADA0281BB3326ABC7DFA6546D6A3690171D802795FC556471
+ 6516A533DB614FFD53F14BF31F69969A9D827ADD0AE7894E54E0D67CCFAF2022
+ 08D0A53B06E3C24B995B191A06C5939F7A7642645A73D6603B59BFCFC69FA1FD
+ 26417C63345E8E55C24BA4486C83E5F9E7D7459736B0DE1BC462A51158EDDB56
+ E4492CF68B11A0877329DCD0CA5BF7320000D93624486AEA956E896A7378F511
+ 2B4535BA77DA0B3FDAB815FF84334C1E477ED6E1D15962A8B66DFCCDBFCE1DB3
+ 2B1DFFDE779E286A7820CC2EFAD87EF5FFB603DD1E89908A72E5CA91AD637652
+ 30D301AB2A6A34ED54145C4D967CFA7C68B7D733B03AFD9F5F2A13A910DE3D50
+ 478AFC83EA796B669FE6E3429262DA5B806D43F8DEEF88BF1753C1EB28435C08
+ 6CFD829D5E465E6CD4F0B1496C547C463FA470ECD761D3184BE1F9C64D3F1A5E
+ 71CBA8E8FFF7EAED90FA71BA53406416B55444B30F5E911C76145566C2144E14
+ D5FF9AA6D6D697541E74E88C834ED55CA1FA888C3DBE0B12FF119407FC042E74
+ 93A5DE0CAE2F0BCF03FA4396813CA33C7CF36A50346C0E77C5A05D2C1EF0112E
+ 91E50D2AF1FCEA7C5D32000F6C40CB9DC6F04BFA3B34F520EC5C46B44EAE41A7
+ 19BEDBB05B144C8973441727D1B7265B224EBF08800D9D71E7E6E325DD1F3610
+ DA440998918F0E2818438E2369CE98D442A0724C7C649B3002123926A3884C7D
+ 5E59587514494880ED0CA10FB8CBD8AC101A5E34EDE20BC1535BB230D42ABE63
+ 88625D1F58BE17E1FA2A89049AC206D54FC28693241C44AA9DA2AFCAF6C42BD8
+ 6D09DBAB70F71250A24B114A7E80C75C07D00EC98E1D6222CE1EB2EACF251ADB
+ 93BDE8681BA0218C6750E47C3E90FBF780A80D99AC5D96435BA6921BC02D99D8
+ D376297EDD9D081BD8F094DA52E1102B0BFA5C6AE3B1806479172F4EE4150F63
+ 9E0C8BEC20891A2D8F7DBBE61BE89D667941D97245A2F991021A5F313DB03435
+ 5ADD100432394023ACCE4EAC62FFD0D1229023D7E5C6581E2AFC2B261BE8615F
+ C0C28A99C509CC95C3DB69D082F77EBFFCC2B497581C42EEF84FD770CBB59EE6
+ 5733BAEF2F5292AFB9682D094BEFF548A561E69FC5442974EB9AD890C6DD2922
+ E28C63C68758E79667B693A7AA31FF9D68404922AA83AFE22A050897E74B3B95
+ CE09BB09B55564959E4E72FE4B548CB60EB08BDF9A2C180E3E34BFF706D179C7
+ 6A4FA5D6852F3A49BB094399C6A112614B0606B3F365A71BD85FBBD74759695B
+ 8EFD060971289A8D6752184066B10C6FBB390549204F69B1BA8896673953DCED
+ A0F4551F9675FA4F5507CC80ABAC924B0F027FBDCC5BDE82BD03B170361904C8
+ BEFE92209499F80581DAC0A21F25977BC26AFCBF11B91EF4E454201497CD7EE7
+ AA83FBAF735A7DB405C97AF0D4F0A71CF22F943200273786EDD15521765B5F43
+ D4935988AFB8DB7C45529AA545310D6B3624F381F8DE281B33EF4870CC04E76D
+ 959F97570BC4B9AAB2C1B2E3BDE65F4F2ABEE6837FA2CC3A49845030153E2BF1
+ 07594DDC2DF086300AA933E189FAA88E7110CACE1C56FFCC63170AC8426C8DCD
+ 68C661DB68FC406D4166D819EDBAA0D07A4E144943F03BDC72AC0BADECE79424
+ AE666B71A1A47F02D6F68F662603348EDA5667C16741C52B2B0EA55819C1B189
+ 23A8745680936C37D5BF2A14C5895AC630E4F22F42387992E549C27570A01FF6
+ 4C54912EE5A4A0279B8571F746DD197B5FAE5EDCB59C3F90EB9E3B505FBB463F
+ C20EEB524403A0DE14B5A991CD52A367B6E8DFB7C4C66A66F15D737DFD7FB888
+ 6970A584A8EA56B28BA8489AB702039658AE2519405EC4944474E3A6CC7D00A2
+ 663F609C85EDF80A061A530159145A4746944D50682F2986590AFAD2CBC9C7F2
+ 25068100CECD13C28392312E39C23C693B9069FE47A667307EA221652A3EEBDE
+ 81191F3E2AC53A7FAEDBDF3E34D4C8AAA902B3F28E6D0B87751D797FBB5D01C6
+ 8965E79296E23C88E90E1F077647F61D2A9DEE4B320453F2B1F9BE5BA901572B
+ 3B09C22FF50D728CB1601698C1D6406562991FB2A2ED41C1CC9FB8FCDFC36BBD
+ 94EEB42B9F9D6DAFC670DA107E08D6D770BAF0FC815F812D4AA72677204F8A57
+ F35EC220D9EEE1C00B66AA94619C79C77BEE4D15A56B8A88D3272E55A6F4BA80
+ 9B766770CA3EB10BCC47409D4AD35A79326D2D0614DB86750F9BE78291DCAE6A
+ 94EBFADB86F79A7AAA85148F868DC831B357603E3AF360D4B4877FA86FD60B75
+ 1598DF4510C78A6338F463D1EEBED2FD3E5D36A691EE981446889F0F6EFCB707
+ 25B849CDD559ABF0153B91CE5315D23760B985595FA0241D5992BE9F66487493
+ 6E080C0E9E498A350331CDC99FAC2C227F816703CB335FA65EE19DF8BD4C02FB
+ 3543122CC8467EFE1BD5CB36AB5F1BCCAFC7C22E06D6B66D0EE90E7C75D487F7
+ DAC8E838D9BE185FFC2B0161A0A2B852F07B42AFA0C0109FD445B45F54C2FB0B
+ 9E1A7D05EE6F36DBB404A1499800AD7BBE69E45F68CE5DA75C92741C071200E8
+ 1D494B703C71B488F75D420E3CCF84A44DEF5BFE5E96D6EF5672DEC0E2761193
+ 3A956AE937663C9DE2D369F2BF719220F9B79318DED7CA96D69AB05A01B57DD4
+ 7A9F0CDAFF8A8BC490D61E3D6B908105D4D195D851656FFBC0A3F06044DEC409
+ 1FEDA6120DE9D2F049408BE754EAA6CE95851FE8E9C69C7561517BADC0BE4428
+ 39A7081DE85CACF4A70C535E30D431F790EC5317D2056FCA0ADDE37438B19753
+ E205678AC1B4800B9B87D222C1D38715A1D97EBB0E5C6E4683C862627EC7D178
+ 302A951A4346D7EA3C0E75E10082DDFBFF9797E0297B7F8F295C38C41974922E
+ A5FB2825AE146C454D5ACAF63A8CE93351746BAA802D75C62E70E71F9439466C
+ BAAB3B16ED2DEFB917E83E3C76455A90A503D65A521080E56A828A09B9961EB6
+ 7721E0F1039D56A84F965E369F83F3E3C5528629C81DD0898CF9B3A0BB86D77C
+ 1D5BA668764BEE7788DEABB06A9374C5A6291A2A99657D99F26941BCEE30CE20
+ 5E22A23BF66432C15CF7830932815944C6CB9BECA435220821228950B3B6AE4F
+ D6E9196A2EECAEF7AB67E411E59A4D0B5C699931D5683E2529FC9C67EFA66CC3
+ 8B9EAD33092C7A04AD1CD80F93C69BE70ADBC3408FFE0B19DD6CFAB55373A339
+ E81B67CAAC2A5607091713DF177A8D8186473049840DF225023126F385439E33
+ A391C5C1EFBE1B2A0981CA0CF6FF32A5B76203756D250002F6D87596B79BF2A1
+ 77CA4D0594333A3F794E953C0E1B7489BCD676B22982D5872A88FF8DD25FB0D5
+ A99D969FCC63E0FD3BAC9D923C161EA0A0C01B77718C18AE52ECA905B590BF90
+ 809ABB389964ACED1D680BF4AD6A47E08D9C1A58D2809ACBE0FACBDB7ED1816D
+ EAA91488B53F639747C62729F1102C108303841F1923AF8BF388C1261EFBDCF1
+ FAF0BE0E19E10903CC9B4AC6D2E54FCD910B6090EB37F225CA010E716854E532
+ 621B42FAEE09FC23F086DCD273D1EB96B3136FB3B27E9674DEA4970C87A3BA1A
+ 23D5387D9C5712F29DADB31943BA71BB06475F24ED635F91A6B2381D15B5DBB8
+ 2A64C63EC93948D3F3052689CDAA576A987167F11A708E8FD98DABF42BC7D0A9
+ EE50C4A0A1578C7B95608450A92F6714459BD8B57F346E792A6662FEACF3B9DF
+ C7F1B137FD8D221229DC424936C38E47F1C977306289F4C332F71949814E7B67
+ E7DADAB2A22E3DAD5D1BA9662B924F3AD9DD56C8AC6B01493B4DDC5AA119582A
+ D0E881F937E3B4A68ED4C54B88FED7D13E3512719ABE2F1975EBC9C5B6D7A4F5
+ F1138CDD62CFC67CF7D1857EA8B20F476DE2DEF30B4FB61A1A10CE1590C585E0
+ 79A21FF1B24ABC8AB6ECF2D12FF90F6F1C6F1BDD986471E948550D36542F457B
+ B28EE92E161F2593B13950ABB09F7984BA756102290681965BDFD693790BE3BA
+ 18159580290C122115E01A9B6C535A2A7514485EDDB79719ECFFA2CC0EF994F5
+ 0F7F5AD35C4DC726DAB05776E9C0F91AB7B718A8F1D0E263D41C1052C7038631
+ B95F5344FC82A84B976E3935E496B01BCE80C1A710E2BF08D8BF1C9C90EA4E1D
+ 6B8F3E81728779570E6E7D5880B7B277ED584D65CAABE492B13011FA0E27FC00
+ B0655DED573904311775ADF8C437B939262707DA72CF36D2CA0CC7EC43EBF650
+ 14F9D820E59437EA63565FAA9DB37B72B50F30843EACDC08C5C12F2A5A32AD16
+ 59DF2DA046D728F988212AEE561C208636E5BDC5D51F8CE743AC0F51A316C0E8
+ E7084A836B01BBE52B4AF4D577E1643A274850AE51CA03F09A78BAC6A3852DD4
+ A6D3B7057D1941C2ED9BEBF7FD9E778D6C78DBC9E4A1228B3DC2AE3D2C5BF29B
+ 0E9D2E4D542AEEC7839AF72944E0DCCC42D9D5B87EEE23BDA5F0AA2B8C145D31
+ 2A9546159AF23E739DB146DEEDA0946B98C70BC84EC49DEF3B07B675AF2B850F
+ 8E72897D1225505CFE2168770E2E00E0C56047B4E1832EB0AAF800A923849AE6
+ A5AB239C96CED60EB1FEEEEBC87F61B7D09FA7DA506AB45B69AFDBB50DED2B5A
+ FEDF3CB2F057DB9F3D41A2084CD35BAD3F3DBE3130D203A49274FCDC0CB96B69
+ D3853AD92FA48A0E55548DDBC40DBC967C61CA1722D539AC5FF2A4F50981BB14
+ 69D7CCD55F4DC30B9782A71BEF4A800319D660B72846DDDCC784D0E5BE931671
+ C0776CEBEE06638040C680273176BC00F78DB504C02AED2C12AF6C8D26AEA973
+ F4C5AA3B05C7180F13A1D8AECB5AD1FACEF985A153E1C8D2ECB5390A4CD010D4
+ DA9E1FF794EB75A012BAB8180E845BBC01E21113F8866739E5644152A243D4E2
+ 235753D3C09FE808F0F24D898C1D0001E16A98487395C8E7E14127E1C2B5AA84
+ D1232BD563B65888123946C6011D3D62E025AEE9521E1287831A397063C21A81
+ 1B3C6978D264B6E5F13DEBABA45D0CDF8EBDA71F1BED1192859A85473B96C4EC
+ 601CDCAC6969714EC2D962C078DC31EF0F30852E10E3CC9C2FA31C2ADAD9418D
+ F37394B4E987887CCF46EF77E68CEB4216381C5DBB03DB0622E86692AE220884
+ 33CB822FD9A0C0842ADB8CD846A42752E1B0A763141E9C12DE50B5E7AA65AC70
+ 9E6E7D2B98396A1CA1503D6E70EDFFE8E59AF260C1BAE67E723AE6AB93D7AA22
+ A0E1553F08657776B47B65595E4C80B2B5854C3E53B265622CDE95FC8C450CFD
+ F3F3F0C3E726D5835A0F241C76328B87BD24034CD4149D44EEE0900E12C34A5D
+ 1B894584EA19D796729AAE72934246BAC2E297B67C1AAADD1CD128B77FD33318
+ 9C77CC3A39D99C46D7EB493434D5755E1A9451156B7142F8FC6ACBDF5F164201
+ BC6EFC4E17EB89E89D82747AF022BF12932F304A9EA74608F7556A2E04F1FD7D
+ A0325248BA8ABAD11557B8CC17394F66B5EA0180B7BC0ADCDCC10A0DD00D2D8B
+ 6ABA03663B4EC94429E35797F32D17C51D1B84F99B981E76E88C461DA28F3577
+ E23836FF412DB62EEA86152CEE704D6097997E3CB73736F64E39CD7496E6B56B
+ FD3F4919147255E28A834E0E4D3312CCCF26B5E87C6B4C9491A4077593C16CF0
+ 42220ED6ACBC6D45042A440EDE4644FB7577A647BD221467752571B5C9774182
+ A2E8908FBEB7236CC327FDAB75097AE989EDB98FC26FF6DBCA4D3960D9076D28
+ 5D7914CFE211985D4B5AE89E91A76A498169CA319F3A77891C85C9DC73AA16BA
+ 8CD558FE6F0F0BEA074544F790BBAFBBC5F919D4DCBAB14163397C35E5EBAB90
+ F85418172A45FE1591D14F03F7BD040BB5734F516062955CEAEE4EA7A8024BD6
+ 3446717366F66F312C7025346BDA7667F098C3417035A6E1C6CD0A28DB13A7A7
+ 2A5820DDF6B393DF5104D2E9D5A2A01EAC67E11C7368A6C0C067CC71E89930C4
+ B206D715D1C1DB9E2085EB1781996A2449535EE44893B76EF8CA5FD03910A000
+ 1CE01DBA88B4919A9F243A93A9F5062356ADC497E707D39E13E68C942C6A0DE0
+ B0947B7484BF80E8D49C36A9FAF7D82E92738F7DA35A5B209FA83362223B7B4B
+ EE0208149E1533850D6E273D49473A97C931A2723697A6E3EC4E10669D8038B0
+ E549084BDAC618644F719B0ABF60E5D80037DD69F518CC459A8EFEAEF9A26E9E
+ 52F99332B2642646A03B376F9C5CE9F35082DA8C2A7506653A1A87A4F7824779
+ C2044DB2E3C4325FC1F6B7498EEAA9020C029A16C2BDA9268964B158132299FA
+ 8202EF498D199F4A6E86E4C3B03AA733861388B56349C2DCC54AACB1BAAAFDD3
+ 0A83EDAD04A9C43ACF166AE3C4940CA5C408D7E1F9F57EDA3A3352EDB90A62F3
+ D64489A098F25E1E0E33D7AD245C9BF747BE6BF41472B19407144176F5CF2CB0
+ 5CFD77412FA84D715EDE78320D3A2E065FC8464153F79EDEF2B7C6528E08D9CE
+ C33A728A96ADE145C727F357B6C6FC4D12AA852CD2D9B67069D720179781F091
+ B3C96C50F6FF1B82202E844F93B547913952D65D1AD2747AB7051AE85953F982
+ EA2F77615164EC2F64E0F01716E4534C0FF313AC70470095288CEEA9DD5C2A5A
+ E14B3C00AEE66E83471DA57A74A04F2E2D26BFE0806C0E3AD72D274688A2F626
+ AC198011BBAE17453232373FFD43543B7D2D8612081865E529073FB438D245C3
+ 81EF2464D158B63FB11691B809C04BA770972F1F28356ACF7FA6A93B62A395BC
+ 37B5E0A7856E38AF59C137908F709C9D36CEDD09D322FDE176994E61D62B4783
+ 6EBC2BFA8DD8071E0AC3B839C6BBF5BB53489D99A5B9FDBB39426D19BF7A467D
+ B96B985861187071C870780175A878666707F79BA65BB6282190B750380769C0
+ 062B990DB17154FFBC9E0766B47A1A100AA7A528D4C762CB6D12AA263E12226E
+ 240EAB39B697EB666D83815E35AE227F808BE112153F8D5EB94092DF72059FA4
+ DD2F22C29BF6586A0C74143295E0C48ECCE33C38FCAC0325DC34083C4537D314
+ 30DA0B61757CC665C60637B7FC658BBF032EC6D71E38A346D3FEF90C1E58EF81
+ 4025B258BC06B4287A58F6F338C49FF7E291D73418E84849687B68FF5129449C
+ B71D9B496AD29BDB6B1ED1198554A53463AC6B6A4C64BAEDD82651AA5D6EDA15
+ F9ED5431D610FF23093C5B751E6A2E34E2254898A5AA8C2B24DC9E51090A7881
+ 6AD3A9E9C6C40673817C9EFE5DF8BD9A87E68DB56BAC5A1A1A7DE5C7F1AE5F0F
+ 381AA3E7FB8D058FC5012A4F3EE369E7D5B8725E2F9D65FF4F330CCDF5A80410
+ 1814E5C7A51A03FBF57B55F10F223D3FB2DFBFD0F1CFA97899C7C98BDD36B489
+ 9C7CD8D144BFE38184155CF7334B16B109A627966853E089149B60EDA2711AB6
+ 54D9BAF5A5B58E3019B7AD52F5685759464E5F8D354A57767162C4B6BEEC16F2
+ AE94A515AD7A14C972F79810039ADC4978438C7212AB2D13881D22F4C551B36F
+ B8D81734C8E555902F6381EF3D9874DAA72E2BC5228903653E4A83325A6D1898
+ DFCA87B86C620B65F953303EA32F13E00B48CB16A4AD36C3266644A37627FE2C
+ 292B8FBC5E434BBB88189D357D3D1A09BA5C6C7E2333118CD1F2325F899FBA60
+ 0DBE0AE2A50FF9BEE8461EC5CEE427BEEACF13840D54D395502298725E5F2E52
+ 43D6ECEAF2D731E11D3095D1105CF2E7D82925E61FF40BE0BBA4A246A48BAF4E
+ 72AFB5E7708814E2FFEDB6364581181DB5227F4F6845C883932CA494AEF5CFF2
+ 0E810F5DDEE6E6BFB92A7057114B2EDD07DF64F0A8551598453162B18432C4A2
+ F8823BD7B2803E11DBE934848A890BBA94CAC3C2057DA6C2F2354DB2DA5F584B
+ FF1647A6987ACD2E00D930B60B1D82CEE902F5D8C5484D6DC649D250C21EE7AD
+ 4CA6A7B444FDEDD2DABC93860DF9455554F4FC03EF08EBC054BD6E60748E0C78
+ 87959A2136512C4A3D7CCFEBDB9753DE99C1D775D3BA0D063FC15DBCEAEC6F43
+ 2364FA2A3B6A8214C7B091B054837F169BC69518B57497A710287D3A38819468
+ 868CD602F9F6BAE616A64BFE863E50E1C35760B12DCB7E3FD77AB339109BDFA2
+ B4EE467781319AECF01C62A471C536D40C9278CB8496E215B8D1638873A18F39
+ B9F8D77320C35E3D0E6469B303D4675B5F869F938C7CB1C869E69DA8DCBE9847
+ DFD91C5D20726C495D327AD823AB10FBFE63CED2CF6E845E4C2ECD91B2B32E00
+ 262891FBE14F7806EE62B39EEADC987E59B5F9B8C66F3337D9A0CF41CF680AA0
+ 0828145769774E409EBB557CB4E25FFF9DDE0F4ABF26AC684EAA0E02D9A9A8DC
+ 4103311A47B87AEDB09498F12CA43AD60B8A7200F3BBE9C3A62B2E7CA976DE9B
+ 19580C9542D771F8DEDC5FC221FB3966D7E3B2880A17B7A0AC15E423DDFB6615
+ AF3DDA48711173F4949CA3C3CDB6B94EFBC928E133D2651A7D8D2D2FDB615DFB
+ CD4A7FB74EC47F2BA160A20AF8A6A793065F77D256E30935D8BB6B5F85C7B145
+ 6C5097554670C96CF0CDD8E2F5A56B2E3DE9266AE623B968CCAC79B228CC4BA0
+ 4BCCAFDEA96CEE711125C70B097FFA99664D844551DB23C8959D013BB43D404C
+ 11680142B9F4F30F8561F8D9D7EAE7D3B2F9B4924D39098A65B2A31C7772E9C6
+ D1CC8BF61EA4A0F237ECDF3DA1A7104E8A16CD0BFC23F6CBF4FCA84D419A8239
+ 52AEF2CD80C150436B385E11FDD013A7A4B9FCA09266ED1AD881A4330F6C280C
+ 7057CA3CE67625A0261EDC82B4C46B7FB35D3F489A4382ABE96DF1C1AED00449
+ EBDFA1830AB7F4D5FD962B5727ADF23CF8DDD53F0601B6C1B359791FC16BBE81
+ A87C4445AC3BFF47DE538A0B9149E0FFD2C70CD9E3710CAB0E3CBA0557EF1D7F
+ CF59F1C5EE80C9B30D98725DB1D6C71F739EFAC1779714645BA1D8E7AC133635
+ DF1BC0F42E086F76F99EFE7E94715928BD9449DD867B071554B30E04A32AE615
+ 299F1E3F6623A49F32EB3D4AE4A4D7B8FD0F950F7E8B0F8BEB228C77BE95522C
+ E2AD3CC076B2E763CA7C8435BD59C1BDEFBB92D50CCD180AA3CC48E648EF2CCC
+ 2D396738A568A8B29A742BEB1BDAD022766C6718A49325082935CF710DD869B6
+ 4BE2BA2E8608332C00476C21211E59DD00E61CC8612B117F7241981C22607FB4
+ 13CB8B0DA39590FF96B5FC7C3BD6C7649593740E31CE4E2A4864FEFA1DE6F108
+ 68AC6ADA104C4B118972FE47C4A76646F3C9C542509DABE6D4E47BFC88A65FD7
+ D73DBF68FD7CF09715CC3D837ABB20087B1BC92B94DDDFE62E953CAC86C63AF5
+ 574978D4A67385D93AD70A5D8A21A9E00F8A353CCE497B1BF1C3C665D8F2774B
+ 80F60853FC6B7E104F49192166A9D68B77AD94699BBB477EBBECF9A972E6DACE
+ 38E396A7424B4683B9B761BF2B290EB95F360C7B1AFECF78F592E8C29DDB8EB4
+ 113E43ACFF9C2631A1A7CF84E5EC246237E20BA40EFBA7F40FEA34C6BD2CAC6C
+ 8F9B3AAB7B5BC294CE37DB6D42D909649FE842EE6C6242E77BE63AD2CE717A60
+ 01903B470A7F4F3B9F6E4C3BBBFEA92ED48387135EE94D74589775FE7C5A77EC
+ 6B2A15B8A67B71F2080F7671C4B0DF6B5CCC42FACEC2666E9F855261D8619054
+ F784E07292D0DC375023A96FA9553CB062DC94E890E039B804682F0E652A8313
+ 6F046D141B600816A5F41CD92AF131F924126DA1B5CD90893BD4D4BE91655A43
+ E70A27C798B527BC75C8C012BEF99D8256EEA91EB1D256AF60EE01B24C6700B5
+ C9C65E62677DF64D28493E3220236DB4F623B67D35C8E945E8F7DE16F80126C7
+ CB5394A14651F588474E01FFF0D607D1B69A7322643A04C5D625AE66C1F4AB8C
+ EE419E84E295F4203AFEC6ACCF3C69ACD68A90E7F35ECD40FF5E21161A411A9F
+ 5CC2437B4CC6C3FC753134C97C6D8D6041704C089E8988C2A15D43E918500274
+ 23CA4AF399679A0BFA48FB073FB22BA4A8C5ED710AE283FEE1BA8E1F9B87A992
+ A4CC05F549EF4F83739796288D6060F03F0CAB39592330E49BCD7D066BE89D1E
+ 8997EF39AFD4CE129572A98D5C1A452970CC7A39193EE30C19578100DEDD9756
+ 13C045A200AC465AFA9B878E2F21408DB9B0A8C3F5246C03718443443DE55C5B
+ 3A6016CBEBB9C974BCCB0F5264ADFC3301A71CE7FC7AFDBBE86748BF036F62A9
+ A4849A763E8553F318FBFB5D02C40C61C58A43ADE39C13C2611EE5845B09DFDE
+ C2A534C5FA1238CFCB5F22A340F9098011A17E93B27E9E3F170F497EAF826304
+ 2E3F9622C36DEACE220B3ED2A4296F2FE8622CAC6AF1C8426F8FAB0CBBC08790
+ F922F4F21E8A84925B916E687469D68E133D997BD81BB5A4A418FC2E731846AE
+ DB9D30E6365A606EA56D7A2360B711B831E2763E616A00D1A4C30DE862F6FF41
+ 559328C2281F1519A9DCF675360C9F3F9146E73A7DDD6665BA1E1ECE269CA544
+ 4115258A19F38B31F656038B025F00B5E6AD9E40D4522A84A6F70A66B16BEF76
+ 597F9909DF0DDD5E2DC4B8CCD92B4DEC5D00D21AF718EA564AAD1EC82938A7BD
+ E52CB064DA328B22E53926A96587B74466A44657B3BB72D6369BC46C09B1E8FC
+ 7D34B35A9D5373DBBB0677A1597B4EDA51DC4DAFD28DA1A41618B8105B1AB2E6
+ F9DA635D4E5E00D47BDE8814D71EC350A633F2EAEE55745BC9A2E0944A98ED17
+ 46ECBA51F664F34E2C93988E76F1B96D5CF747D5F02F2A5AA230C95E44FE7CFC
+ B59C40F32305B7A41926121C4CE3BEFAB1FD4A3C95F8A8497F4BAF2419F97467
+ AA6F49D3CFF701FC31072152003D88634A242526D28FF3AD5F6BB4C3F2D6E2E6
+ 3A0D750B3159306EFBE434CA40805CDF39B81141963E6D89A709697823687C99
+ E50AC3B730598DB1F9E3E4B7A7F26C88F2D34B0D97A20D674118DBF2EC7DB5FA
+ D3B2310CDBD81D7DB0CE41E8363B36D18D05BDC6BC312BDCDF1282BF616852CC
+ 17C3BF53B606DE9E5C5A5EDDD75B8BA65F209AE752B1E0D8B299DD52E5DA3074
+ B41360EFA42DD11F970E9C015D3A9467C67119207FBCD14819AE42248CEAE2B6
+ A3D9FE1FB0173138249AB17BF21057CBF1B58DD22DC396B8B529FBCF9EA57CB9
+ 82ABFB728B8D291610A804C48669A211789419326036216FEEA7C60A2F5C046A
+ 6DD795D83A0089379C80FA929FA89D49314D02B64BF0DACE80968E59EF8E2227
+ 74B318B4E621E54404995001C9876C380E436DDA922E8A3409BE49AED6D9F36A
+ 388B22A808FD68E36AB76851E24D8A89202C1E68C902C1232ABE8B99305F60C4
+ F0B83DE4C11CD8BDF4DEC503BABC2951DD4CC976A5E8ED3DC36607C4529F60BC
+ BCD5CE7D0929F309E7973DCB0C7470512B105444CBDC2003973F28C29E150CE5
+ 84025BA523998B0EC703DA475644EF3E31A0D429A106C6B8080D00B33DFC4A84
+ F88943CC0DE49287C17A16C5A165D4CDC6C9059AFAD777F904CECD4FE0CC4A8A
+ 3670804333F6DD67442D5252B63EB01194A510E06B7373A6FC2D11EEC3C7F1E2
+ FAC6693215648DDEF9BA91378FB1BD25A92BD0BBA44000102617AF493D9B4E5C
+ B9FFE0535CD21F55AFDE228F88AC8E5B0000F9B208FA167022CB8333D29C7EE9
+ 166748AB38E412320F5C2DA3A1CAF458D79FA9DE7EF7D996CAF5842EC0F3E13B
+ 2F69DBEBF0E26DCAF25DD535B239BB55EF1116C4B72A03D5F9575F6A22646FF7
+ CB494387AF10B76906EDD5A3CF1DE2CDC9F69C3081D0E9CF6E9E38E7D6987C25
+ 6771EECE59131EC41B7E20705872CC14C430129713D453F5C19FBBDA0EC889FF
+ 528E45CFA01A3B89E193DD532BE8BA608E828A96D2630F1D37230B5CA8538359
+ AB1713544E92BAA561349BABEC8B3353C55FB1F00498A5F27B14A961EB972DAD
+ 57236BA9F571EE79E6E5DAEEBF7CCAEA76493F5B3846D7086FF457D6BADECB2D
+ 57ACA32E33FDA4EAF31998A953F6AB9C5A9A168E6ECA10846995B654ACBE4907
+ CB2DD93A2E673F7272FE5B54E88D8EC16901D48F882840C98658CD8A5FB44BE8
+ 112545FC21E2DF4E12395ED0CFD367569004DDBF165D7327A8B18625FFF1FC24
+ 885B9B44EF7FBFCA65791A2F070B37CEB7390D8D7E710668F79942E67336E788
+ 410B77D4B5ADC78BBAE4DC5E532FE0BEABD446EE73852AFB04C480A2F02E984C
+ 8A55E35D3AC57AD1B8F041C928D9696216DCAAD9F292AD0C1F1FB2AE016635C5
+ 345E725D794098617555D7ADABF476DAD48D070D2987B3F1AADB90D6F29CD3EA
+ 27BFE15BEC2ED745AD6BBF1A49D4A7D77A7E82584B7203FFACDB56AB6E9974DD
+ 28797CFCADB30CDE95C6049543AD6290BECDB00826AEE0F1C03AF9F0580A38CD
+ 73B5E8DF5C58254CD6863A91EF0FAFA19D2053BB3199CFC6D5C62D2BD2541132
+ 99A953417F88A6D8B6DD2CEB67C2C28F8C69BA4B23D5788697162233AE60E4B0
+ E69720198BDD4ACD57D200619A8EC1AA0A8DC6A42A042034C5C3CBC0E128A483
+ C3159145DABF18EF8F7C64A354F78AA0767555E1A53666712A85FD704786223B
+ 80E00143064DB2B8049E0C6D3B48602B7061CA7D9F7E2E18C5CA162103FEEFC2
+ 46CF31275C9ED36F9F81A3B55BC13E7CBDCDBE8AACAC609D82619DC0DF63D8B2
+ 540471E31BF4D81818A796AC929C58006749FBA0DD95FD7FC3733D4C20ACF9DB
+ B8C064F86136CEFABE8B1DD5EEDBEDED967C9C909D5F6B63D11E60FAC94A3D66
+ F46A07BBBEB6880C127F2BD11E8932038E2D45D4E069059EAE7BB89B73D6BFA3
+ 5EAE6EAD71C510EAE5D1C30622F1CFE85A7B44C4F70558C1898B737B51C958BC
+ 6866402DC4E4BF230C618CF46E933B33448CA069D290DDA0557D045E39F03EB3
+ 1A3F2EDBB8A9D8FC3A69F89888AE5089687C34541A94DBC9261164E1D869B347
+ 9F479EA6A2191EC725A654053EEC6BD60D0C5B1D9C954236B12731F554661CE3
+ FC633DEAE9B80A31D4F3A309B4DE7E5611F76FB37EFDB3E6AEF203155408176A
+ B50AFB57A54C5B7593D3B50DAE1E08B18A61654A33368EACD705AA0A6B318C3E
+ 10D4E3A54D34AE0C1C47273565021A10DE373BF8D87759460BC472269896AE33
+ A09BE800AFAEE9DD48046716013B4E5F816410707406D583291ED4724F1FDFDA
+ BC9D2074A92D8B73BB90122DC17A7D080747DD12492692594FFEBEC31B75012B
+ 98C75717F77BB6EDB93FDB18CDB1DCD17730F4AE30F1D8FB587AFF3EED240CA3
+ 5265D79F66CD76C6854420412FAD628D85CF27FF28E32379E9560132275363AE
+ 5786997EEF98A8788A3C83CE4D697CF6004100964B967D37BE2680DF37D23E75
+ 263125076A34BBDE82A98717902FD6D0D454887F7E97795C0ED05BFBB56F2C51
+ 2CAAD16DB064283BD3FD95556EFB21B6C08D3240FCF5CA30BE6E6799B0CFA5A2
+ 1B2E11308DE86CCD787B1C1D242D503DFE4BE6C475D62E2A077C747760C208E3
+ 22359CEBDAF48966F6E9A8C4DFD54C5E529875E0A4ACD2543F9D449F1FB61771
+ F94667BA64D32880B1D40B570B8390BD39368EAC441F997B2DD38C9F81384CCA
+ 701E26A70998CE37CC36048CE88C141DA5B654561560D88397DA21E0FBBF335C
+ 00F8E85D7EF45C97908FE58242247E552FCA9BCD4C8EBD5A990A70004BE23617
+ A528B480DFFAC8AFF64D905BF3E6967C49B49A51DD8D763847A9A305ED545049
+ 552AD059260AA0213D7C607F6C0CC81ED69696BBA91B849236638C1429961A78
+ 5705DDCB98D416B01C81D941723A98821244D16E390EEE877EACD7E073AD5F5F
+ 2B2F7F58F8A94BD6B99BFB6D8807B62517AF5B131E33AF7903F9C37064226A61
+ 262FBF82252BA9AAF386BEE7F1F40F837620F1B25FECA3C42893ECC5A22CF907
+ 7F9AC8C61693300BF708BB36D7EC2C962C7189261883649E19B966CBC65B1B67
+ 885F18B2F5510A6A8AFFAB4EA70FEC348595D4E6AF209BEB776AEC93026E7B3D
+ 4BD56998CA9581920EBD8E8C16CDD4D59F3D8FC5A30FF7167ADA681F26D700BB
+ FC2CD12C192A1E0ED5884BDD2DA317D44FF93956F7CCE431F8FCB37C8237FA2E
+ 15C954E7501BB8F2D8B2FE887FEB01437101E906FF1FA0178BA0313A1843D893
+ 5103A28BA57757F8015E3D30F512D86E5BB0A8B769C1215800AD724EB37BB00F
+ B9C33E9356C2D7B78571480A553A6AE30A75FD6A53471B63EE62D80E2D56C712
+ 6A8426BA965D84FB4878C79D7248580903C90E972F2D63878CFEE572A88BD08D
+ B323E7D756906D95607EE0482204F17FB322140E37E4324EEF64158551A1FE8A
+ 3186707B1F79393AE43B6A06D4D90E9F94E4A0CAE47D28ABD903B47F8E780BFE
+ EEFBEAD19E7F77DA375A5F11355529B3CCDB71ACA76A0EF081082B8F2006004B
+ 5E179CB5ACC58FCAC42DA08169074334C926F2807C56645FC36833693E905303
+ 34F419735903D0D2DCC0D4DC0A84702A565CDC8D59B2B5856980B44C93AD2554
+ 6BB8C8F63B5F5BF15DF5462286A2E56CDD6358BDBC6D180DB5C1B79B8B0F975F
+ 9D52476B9E5B57C6661C47A2E87F476BAB62C4D3E24DB2D25562B4312326C972
+ 61F932022233933E5FB107056C606BFC79E7974D7CCAC3A353975430600144C4
+ 92EA9864CCEDEC277A1B628167CEC9D157E040AABDC4A45B3E873A38C42846CB
+ CA61E753EEF36D2E85EA62A0DBFA9551D48070872C9E940A91C85FA9AA512E3B
+ EFD9BC5AE7DDBF48DFB0172ABF8BAF75CEA718F4B4A44AA9F052AC4E54FFD64E
+ CD047AB52FE68DD536F91DA3EA560B8D7E8D61A4EC02432C231CB3AB7E7F07AD
+ B2C533DB69DA3455A7A0F0F0DF280FF973D6BD57B5F9448C0B02B642E6E698A8
+ D08C869367B1D13F5E74A70F52745B635D3A91F01E0022192520980DF7F880E1
+ 50EDDB0AD9AF30C07E7C2CA953683BED8AB4C10B4B9CEF4EEC8D9A4E3B23D6FE
+ 08FC28F465231D63303294D7AFAC0442DE88DA76243769BCF96CA139EE4D90C4
+ 5B7C0D861C2BB9472F2EAFCFA5071D5AEDA255C86AA51D45EE8ADEC2FEF6AFD9
+ 5894238B5089422799D3D3827563CD7611F1C6ADA945D4D095EECFDDE251D3DA
+ 961E458BE5D1CE56281DC984C1D11C6078C364167CA3811492A25FD6A08DD689
+ 7F105F26286AA6AD703765791248F68DA8EDD415227BF7556062770BADFD4E82
+ 2B973D1162857867255B1C19A2D467BE18408BCEB55B0254CDB2B4EDC5DD7F6D
+ 9EB5730C69DDDA161798F93971BF6B649B4693282C68FDA02223ADCC34758463
+ 8C8DF0ACED1A973F913F9598A1F6E81F4588DC8620E5F930FFE72323DB0EC0A0
+ DE730E4DDB27AFFD5589A47E19E76E9F8E5B67B261009E01CD834806DAFD4B0D
+ F323ADED7D13A5AAFCBE9B6C97680DD2AC795403A176FF06E7D3EB45FA8ADD88
+ 1948DE04E37873172C39F6645B1B1885F489E1D21A5DC2DAA523E5BDE832AB21
+ E19D7DFBBEF14EFF3515E82E647F67FF83765E58D327FBC66B1826B4691AD650
+ AFF337DFE14A757537C3B48D864217EF13D953E6D3015D5732FCFBE650AD375E
+ 72D0FEC888135770A84281133CB16D7921A29E131B6DBA20F51FD27538D94C92
+ A3CB360BF36EA33D6C4EF250B07FC5EEEEEF21C65A8602328B33701AC1834CDB
+ 5F70A33825AA741FC1586709A470C2BD79237B7622F5EC8166E0F68E046CDFB3
+ D41740B884E486816D890152A847A1494178EFAD770A2348724930904B82651D
+ 2C414DBAF50DA757F7F85538C04C0F8D6EBA9C83E000F49BCC45D94A00CBBFBC
+ C7847A5E3A3ABAEAA7806DC5CCCED114DEBBD06E4F4035C7315AD1CCD71216B4
+ 8C7132380ADA3877496B3150CDC80D5BB21F6BC0DD6A426F5A752BA753E8A858
+ 090E68060A49A614D376023781F084EE968B3AFAE998812B495FCC38C10E801C
+ 665CE0F3FA69F4352E441D330AD94E59508AA07F97DD7E7B8C83F91998F8BE3A
+ 25CBB20954F09334384ADA28F449ED2A0F8450F11C42880A32B750B378A4214F
+ ED86BF2FA20D1EFBC91C1BF45C79A2B9504CED6CA6B51625241122092446088B
+ 521FC6C37F6E4AF9403640415DF1578FA1B0FA0C1E7B88F4478C683F156E935D
+ 59DC87B35465AE7BC6B2CBF837CBB7D6150A9A6D174A8E5F53897BF6279CC2B6
+ 99555EEBE505D1FB8A46808FC3E7547D8F3AB1FF3A892175603AC7996656F0C3
+ 67F2C343810E5AE520802575A0CF2FDC62F2FE725678A8BBEE0E19736C62BD2A
+ 7854CD94DC84B37F35C7DA901DEDBF4A8853DBFD33E5BB335CF73257F86733D8
+ 2C50A4D1E459E9877598EE8C31FD1A36D9B93316CDC48B04ED0F6ED5592EAC52
+ 6E0711C97C3DFDD3441E95F846735F25B6F8C78DB9DA5B0F311F37C35B0B4BAD
+ C1B51AD0665391D1D85612CD2CDD3FD024D6359E8CE8F2E7A480020B3094131B
+ 5487391D219E1BB34D995000B9BDA33C7940B0969BC721AD6A57ED686701993E
+ C6648DA477155EFAAFB55236FAB8BFD0EADF70F94610CA0C757578829709F43E
+ 0D1CD0C45D02BE8B67709AAF9C0384A2AE393AE29810B4EC507913D44FC82F9B
+ 6E22C208AEC4BF51C647801F3F6E0C2BC439DEA72839D54C451DF765AAF26BEB
+ 5A09C32E619C19E8D57245E78EC67206E02FD5B01FE57BC914BB86E3AFAB5FCD
+ 8D91E95D361BD7A945CC6D519ED32318B88230BBC12AC6C4616DB730A3B420CB
+ 5A17F50862BCB58D54AA7F2688A5ED4FE4DBD55F7666272E9D390F23D5CEE435
+ CAC4C8B93BD80CFF52A08E0FBAB3DF298EAF59D713020D39F44AC0CE38BA9E2F
+ 19F438AC89020645C19C2FE34566C7B488A9C4E9831C8317B64F6B03D7971CF6
+ 2B7B5D904C3A41556070FEF518CB8FC1EBB27EE0C6DF665D3D9EB7DCC3130D0A
+ 7CBFF72F9E79F5DD3540B2B07030B63BF23FA47715EEB43DC3BB609C2BF1FB9C
+ 4D70AD0316D6D42B0929F6AA9640F96D4F7775DD81E3A10D87A6C2D8792E7309
+ 06F7E940481C8C13C0BFE94BFE4F18EE0AE6C3914DBFB095DE37349E4CBDA56E
+ 7607CDBC349ED671D5A647E707071F0B3281B2D6EA45B4D0514D202E2D5CDAF2
+ 723A36EA96FF402220ABB304A6057D4DA19B873313D97AD5CB4BD87EC5392C6A
+ 115B16AB0F187AB6C148AC4FBA3E0C6AA80DAB86990F3D31CF23D491C6E2A94F
+ 854902B0B1CF42A8A6E1494396CCBEDE0CAB44DCF598C72BFA26F5FA7D95E166
+ 8A98CD91D041101EFA408FF6D62302B29EF723FB593C92FEB8FB295871CB8FC7
+ 34404A665CE0A622BB2A6C7D8EDC45902BCDF2E3CB5DE40424E1B9E872C04BD0
+ EAD8A290B5D059C2AB5DD93A2870593A6ABF5BB0CAA56DE883CFEFFB2D8A7C7E
+ 84554AA2A1C3C8EF9DEA1E9B3082489D2400DFF2CD13000A7ABD2959E8916706
+ 0427FFBA80453A860FABC39CBDDC632637C53E6821E79B36C3DC4980266FECBA
+ 13CBCD18E864C65F7B2669AA5D0C81E40190D29069A3D0BEA22494BE4DB8045A
+ 5BFF397557B5F37037CFA32DB7DABDECBE1A664FED7B4C6E12716C1DAB96EBA0
+ 70B76581766040C32EBEDFCEE1F56BAAACA5E9EBC6CF852044A9FF1420E541C5
+ 7DCD173CC704D17DAF151443483532C2DCEF154299524B53236D2CF107436258
+ 028C44F98A2B117FA6C2F30CCC09CBD1AC62A553352B4D5F0039A90C4316FD4E
+ 1358B2674F9CB9523590F0B5598AACB8FDB392B8AC61B23D39C0C4477AA7F009
+ 9525F2CB35D4BEA4E4A985CB21F656C716C20E80255BC64CCA3CC8377206590C
+ A420CBB0625A5C4FD4BA21072EDDD4224FC6E97DA1AE87F176F6793521053D91
+ F718F59EA28D14D730CE181D331CFCEEA14239FC5294DCD357AC08B7FB1D5E6C
+ 1B4D4A0B01D5AD7C816FC6043D716273F2D56BA62586BE6B557246FD8E0F6AB7
+ DEC1025651E06A65DF17A74E327CB16B32A0BFEA832B554E6CB47A56A2B9C069
+ E5C399C148639323C25333F57877CE9E1DAEEF3D77C65B452B2E85E889F89B9C
+ DD63FF29A9399D5AE5B506E78AD3E33EEBF67110D36C926B0305EF7C320D2E4D
+ 5D7A16FDDA49035D2211EF013865486330F2CC95D0F2C488D4B4954892F6D00B
+ F3345E5BD98276F0B00E257AB0B4770C735BDE9CA14850FD9C20F3B507E45490
+ FD7A8CB51B02A24D9F7AE897B9DABFA4CDC9C01951F8CE896BB12239055B414B
+ 0DFFCDB1F45B76A0AAD3ABE647B654562BBE72A8A297DD1CD4D75798568BF3BC
+ 9B1528FCC2A2123ED7069ACAB89981033D37F5BE4FD81CE5F0F75E3BC1F2709D
+ 279F5B8468F91DED59B3D694744167C0B106A83C24EE91B937AC34D213FFA00C
+ C56CE82CC55074132CF409D89B417B2D2277FF50F35A3F4CE0528A48D573CA78
+ BAB6901D3018E21C596279A3F83E72A622E9D163509BA641DB91F84424F2A365
+ F9161C0674EECD8E84028DD1C10F84422A2172F24B0ED9332E66092C368B9F32
+ 4128D263E82854A9E4BED7962963F264FEDA98BA7A54A720D3ED1AD40052FC01
+ C5ABEAF419D8296092347569BBE581ED79AF630324DB76C10C7BAC968B2AB848
+ 451431238F54EB745D85328A7084CA4B607F151FB568BF03444B867CB4FD219F
+ BB771644619A95779C8D3A0C05E882BB05FF7805AC8054E48DD278755BB98D12
+ 12D49AA87E586197199837DF7E84F784481CEA9B6141240CEE315102E8EA836D
+ A8CA8607253522AD474B54D829C13AE9F3F3CA56C2F5A383E635ADC0B4831368
+ 0BDCD6ECB40D4D191934747650C362651889AC4223EE52765A5BC2B23CB9D684
+ D201BF9F50A3A57D260BE6CD06DAA72555B5CB5FD863066B8E39ADEE699D2BEF
+ C60E3511FD0EEC10A8174CFF5E95101AD33C569743FC24C1D737B8DFE275C856
+ EAEFAC70902FDC4D16FF7C933F0F2387FD968C700E5EFC5595D67F2623E7E76E
+ E4036951A32312633896122A41E231E974E3C92067843AC6018258B964C47EC8
+ 6913266745B640D430C5B3FB103439AD2A9188DB624C0491BE47006F12747E57
+ 962D7CDBA7F817168283EF68DC1609A273857A5ABBE281C27DDB9D941329B91B
+ FAC4A25DC32287A7C196C52FDF09F5CD85AE39917FE5AC85B788845F53C91DC3
+ 0E93865A370F6E49675F3CC876E5A6C4CE8D185E5934A2B236A6F18112C95517
+ 75DFA754E07C5C47CFE7B28A3E94AACF4F358DC0450276EC056297A1EE974173
+ 9D3AAC36364A0D8E941576BE39D19BF3B2796802CBCF56448A0739CE2D49276A
+ F82DAEFB7FFD6D3CF1D1B9AE76090531D978068B737FDEA49DDF17E6AB7AB32B
+ 3F5EF71928CF664E3A954C45337CCB7A2AE8E3A029DB94F36D29913ADE24C887
+ C2D0AF73A21629CB3A3B6C2BEA6B1C274F83F5AFD7A6E54B03297971A58FD8C2
+ 463DF79CB5AC5A720BCC3B39551EC05D464708A3FCDC3F9E2B46FFA25BCC5772
+ B74E27ADAC70EA7D319D500D5531A9C6E608AE5A6D8722972FAF3BEEC59A7B7A
+ 63AFE181A09430B16C0711D5177F9CB102C04DE48BAC8290C206BC8060A4E234
+ 72BB9F75059C040BA1BDB419683994CFD5F8AD4EFC09688680D4FDE707931ECA
+ 7FBA9EE94D48507752DD27B0E887A74F256AC83F96FC1FE249610D20B6945579
+ 46E6F6E54B4CCB80A08306AF350FD53DA0C80C8D9E3F308D737E91AA00571174
+ F9AFB8F82940DC35BA9870DE3071FECA8B2B5E1C5462C782B060F1EC86C7A8BA
+ 93019C356008C8A9FA0C8C7F42A17525BB42C3360725EB1CA2689AD7513B2B0B
+ B729C9E45AFD9B7192473B0EE3066C570BC972FAE9620EF23B6C21D63856A6BB
+ F9BDB2F34B6D6F67E0303C1CC6CC2B65E01BE544CE74B08225C929C6CC8D5EB5
+ 6A1F51EC5053DDDB783A5F9B40148D60D14B9A6F2827630AA27C42596E75EC23
+ 12F94D6D258DBE1CEF9C484C2942C9A55012AD1F1554F9C1BA56CF8BA6FBD34F
+ DBFFE85D912DB3112580F54C3D0FCDFD471D65787FC91D9E108C98BA5F42DB04
+ D8BFB40826798691A4D59EE800755EBD27E29D5EC89A398AAF7CF60008B0C8D1
+ 3DAC1503F10C2A4D35642F69B7AA7B8E2499DC1729B748FD48993D97944A375E
+ 56634ABCF3BE544896E054717380AA52A2BBE1F033D142FD0B5AD54073C37C55
+ 9FAB88A31E131063E3EBDEF51D8B6630727EAAB23B61BFB181E901540B0DE9F9
+ 107444E0A64BEA33C887D59FA18939021C207F1EB14416A0A82C674DC12143B2
+ 404B03590BC345837891085624655142D413A1F4D33DDA867DD6C911E50BCA29
+ A8E27842731DD469875A1B3D43DBDC5B9A88C56D7A2D11AC2F4912BE29AD407A
+ 7540BAE2F79220B4E0793655804868D74F96688DA2BCBA1180B25768881D1CED
+ 0AB008BCBE46CA592F1B148067C8F65DB1AFE00D02332F965AECACAD64403439
+ 353C284DBFB7772D2196327CC61FBDB8F46460FD8FBF07C846DD464F28276995
+ A8BC90CD6E727FC7A62F748592AE5A0759CEFE26DE3214F3667B496401627837
+ DFA948096F331C18F8677F06473CC09DE8DA9C781E4CC296991D938106F94EC5
+ C969952F4C20C9E2FC339C522460D6BE7803C741AA446FFEF306EA994480E444
+ CE88088A20D4350674CD2E21539A423681618F2BA3685DAAD8E118C4D218F1AC
+ 16375D82898ED4B7784ABCA431301434BDF7BDE47F691C594074B63689187CFD
+ 472A6DC5EEAB02D9D87293BE4C4ACDC30C1CC0E1AFC1A8A357A44159512DDF04
+ 3A1EF9AE85D4228A75C27C2424EADAB56822473B11F35BEFCDC4CD62E935A8CE
+ BAE9A59C269360DEBC4281A2A7B91CFD98B771D7E7AC8A23C7887E80010207EB
+ 27E139F5FDD625213D04B4AF92C381FA0EDBAE2B7A5D377C7DEE182EF9C20FA7
+ 4BB2CFDBD40EC4DE4AFE859986CAC697C263C595FB90C896E37BC7D40A582484
+ 99D019760FFEC78EEADBBC5105E1CBEFC0B4F8249C843C23B0A8C5C9E394231A
+ D60B29B79B262CC6EE152A528F3D65D076431F1D2D5C1F9B82FE1D71EB4ACA9C
+ 1989BE0519ABE081CD11F95A1D60DBFD64A0DE51F8186EC7A89BE9C6EB9A9064
+ 2829BBE5575366FE83F3BFFB5CF760117E4EA21C0CD857BB4F0CA045AF3609C2
+ 0F8188BCD18761836A5437B42A764B5E21E40994CF369A8A84B2B851366E24AF
+ 3F0E2A46D380149E9A19E8ED0887ACC0AA7E62FDD8E6192DEEAA3C363588FD4F
+ 0954F098FA3D5824E320AFC9FE55F21CB7DC8E5A39B30770753AC5D5F080DEED
+ 6347AA90D7C33A79554BAD0EF324D79BAB08FBBDFF674B4579DD639B0CAC1ACA
+ 4A2D4990378ADBBB22771623AD5E037948D27C63AD9A4B3C7855869B4A947A34
+ E43221E833869A2B08D23249C3973FFBBE1B996FFD5F1CBB1331000F1104E908
+ 5835B43A22C491B505916FFFD6B80C63593E7AB3B9B09D2F0FD869CBA19B51CF
+ 78E438409C2A0541BF11D87787781307F1623B0504909608475D8DA16F4B5B53
+ DC9733C67B0F7959FFEA0906A83D773CFAF539784B8DB34AD71A09F84EB28C06
+ D881F3A28B5AFEE47B1CDEE063B424B7C8782DB091C4016B2319A1A168D5A965
+ 09D4B1274BFEA67B3802047F7C5F53B420FD47E6DF344488F2D9591B852E6922
+ 7ED3EDBC851E4111A19F88DA5AC2E9C19E123A5A30B9E60C2EEB163FD66EB17D
+ 8A41257BDB90A9B53004F50DD6CB45EA97E3DD2BC6CCE285DB04648D8FE0659F
+ 9433363B5635A545558F175E0858A947DBDF94F6FE43228294C039F39951A732
+ 18C8F1EB94D3551813080C2AB49F84D0510C5516ED52D7A987520BB4A7E037FC
+ FEDB1965BEE81461A2FAAC2C8E67C692ACAFAD12C0D036ECCFEBD35582048823
+ 41E767A95D956F1DB6486A109484979986A40E1F66EADC602EDD4E91B3CF68CA
+ 9D3B36FCDC6989A40F0689DB06C9ABC7B953AE56377DDBB0832D5359DDF78E78
+ 2B46E684A751A58ED2B034D40FDE50F21C6D5BB0154F9ABF491620AE43A55D06
+ 062BCFD01AFE91851655BA5C519AA7F866BD92C9FC1D5BA73D826A2EDA71DB0D
+ 8FEA4ABBE12D0E412E82C775FA4DC62943D426471BC11FB0971AB47093DD98DE
+ E4A7C05ED6B922F7DC720C01F1CEBB6AA9B76C83580DFBAF96C84A8DC2112EAE
+ 81F706B06223677E71ED737B8A0916E1C06DA5CCAC0AE5FC30B086033ED65ACC
+ 1FA8463863F778F0DB50CB3A5373D674933E9C53C22628391AC018AF2F70E514
+ 0F94FBB676B88334EE6D9D5D6627DFA7F804CDE488CEF0393472D4566812A433
+ 90892F435464E7281EA2668ADC0CC9AC8204ACC1E8A82D0DE8035D51FD861EC4
+ A5A73980B92FC2F89FB426E6320C74F385DE97A89AA3B60C4674AF0141E3CC9E
+ 53B7C04F1FC407383AA2255C0BC0D2D761C76BF989E9F73EB42A86BF091CA4FE
+ 7BA378C6074F5610A9AB8553590C872DD4B06E0AB2B72AC26AF0D6CF069C76E5
+ 4C085E7787264CB076328689216012B61D6BE0719838AC97FD463CABE92A2CD1
+ 5723ED1F45C35EB8BF9B53A0BBC660D0997036BF726CBCFA70AA92D6882AFBF0
+ 926767B09B22FB76FB98CB130FAF860048E871817B6ED6DF26450B35377D2A0D
+ 032D1BC919366F8FC73E3300D23F9B3248BA9DE1A662E3A813ADAC64B2D9D447
+ DDD976B7987DEFCF123770802F8A51F053B8052654633F62CF8130D3A5C64712
+ 891751E0B8A4932D3C96193880DAD47C241356DB1D00C27C759495FDB68F0D7D
+ EF4E13C7E7B05E2A7177D33390482BB70F6FDCB91306B04B546F1552EF60F1EB
+ 7E38CBB26AC43119023F4EA7D27379E7BA63C75D5B030DE07230461DF99B87E0
+ 458EC644EE081D8DA094232560F5C5C82A2738DFCB2DFB1308F4FC6BC7328DC1
+ 78C56B15B54514842E4B4FE510103EC82A2C01B7A1D9E55A09F24A00CCB4D2DA
+ AF59645BA816FAE844ADF976873832AA9E9531294F07883C07B3CC8C2DDB5E9F
+ 376ED661DCB29FE6A16F39C6D2015794686A445CF3D199E5575855FF96A970AD
+ 770163F3B7D51752AB9714CE45373A49AC7DA69B431EBE454F6A03E2899B1A5F
+ 4453C1461F772B42598CD4798A629123504269A3D05748F35A5C8D00729E7D77
+ E8D56F3306D2761C7ECE006547A4E2F68D280AAD75C1933094C600E37FF066B6
+ 7A2135A0BF6AFBF1F7177225247CBAC9613B517E0EEE5072E13E1B009E741C37
+ C382F32EFBBD1A06E289040B0C85217D4AAFCFABFFF243A68E66A349A1AC7A4D
+ 042179A3B306229C7536F5A5D33A80766F5F876A5C661AADEA026CCFBDBA9006
+ 448A623211365CCCA37270BFDABCC176E4A5EA1304279A88CE911B094AD39B82
+ 079B99ACD88BA450FF30E0AEE132DA10F9172BA5C7E048DA733DD9E10BFE3124
+ 00B5380B5D532D3FFBFC2336D3E29BA31428273E6BA7856AA6230BE0EAA2C52F
+ C22E49670DD3A729129711E52D9CE911C3485F21D64075C683199B05859D8FB3
+ 8AEA45ECA75B4F5018CFF073FC65D36D22DC10D77E337F3A6BCDF51ECB4AAB16
+ B366CF2C1DDA4807CD150D526281ED2B4302C235027874A4FD0CCCCA048EE706
+ 3018B4220D39FB64739FF5F66336940E83999F1F26CCC6EE8AF09A024E498203
+ EAF86DB981518EDC7A2F6083C5E3F9F6290FE68ADB22CA6783269CCA36AB5CEB
+ 432F70BDA27F10C6C22BFC2963250EC836026BAA4FC39125B199210E2A3599AF
+ 9C1D6123D4E20C575CBA61A42D9BEE4EE82B6393C8222FE0CE69A2DFE87EDE6A
+ DC58A924FD66B166CAA71EBDC6F845859792C128CAC493BAE3DEB4139385A5D1
+ 2045C8FF34A751D95C77DB8F6F4C2C5BCB19C6130381C35A016D02B67306532E
+ 85D621D1A6CCBD0932FE1C746BCD79E2202087BCCF86470F857963E530E2F2A0
+ 7A2DF0DC3AE016135EE86E30F90C61FE45C13D38AEF3F4B091621216268ADAE5
+ 2E1157CDC4848E763929DF68650D91AD487D648E79637B07BBB9852592D7FA1F
+ EB079E1F7D3F73EB3E4FD63D03342E984411086AB89337BB2E797903C37E23D6
+ 8FE8CCC45D36B3B412A63B98868A7ECF05B2EF279CC6A4DC0BD4804A3FA8B394
+ 4EC7EB7D8E77C8CD3882BC377C98F349171AF64B86DAC0914661739687072085
+ 375DE236B566802F5240A23C14ECFFD87143DE9429B35AAE04E7268C39C674B6
+ B68F7AAC3E802CDDFBBD05306E85FA7682A846B3D3FA8753CA2CD4C3FFEF0BFC
+ 4A7C43E154906FAFA61A2FB5FCD2DFE6862F41F95FAD9D39122A095BA2EF2CC6
+ 888B5728034C837EAEB2447EF7CEAAFAE6EACA010C96EA825E605B0606BB5664
+ F65859955707C46441C28FACC1B99040F936F460461722BCB7D6393E89EDBDC8
+ 3D666953B1581F84E0D80B95514A6658AB77F31B64A1B3A455A1AEC5D091FDE7
+ 19FCD88F56291CA1C7891C29B2BD235EF6667E9D89F79BE0611FBA61EF099A3C
+ 6B92687B64E33BBD0FE66D7CDCE6AE5ACA787F0E350AD5B014198E55DC506E07
+ 76E3F80191B5042BDB912762A98D2E5AF12C31F491CD01CE6346862C724383F1
+ DCD028C4595E24D90D95A4820F0D5610DD3C7BD76D06F5BE16EFDFC2A71152DF
+ 1EEE1DAAE7E6712AC4BE9C04EBF6517B6DEE63D769992339F5F551C59816D41D
+ E77979B8FB5BBC88EC2CA1FAC5C1A7BE28BF65CC967BC02B05DFD07DB61F4ABB
+ EC5E421BCC65A73F216B0D2DCB69F581F810EBA2D724D21A49C6CE76ACD7B78A
+ 03A5B99190BADAE16FEBAA7C4956ADAAE0E06E7059BE4045120E13CBA4240F83
+ 73471905652086C39398BACE097F36209C30335240BCB233E0115507FD9CB40D
+ 9768353F2C55D27261215D3B4C0A10BCBC53F09788F5037A9AC50859CC1F107B
+ 7D52610E30F21EBC463D33F460AEF1D75E9B6A2734E66090EA3977899D29F34F
+ 2295AC7960A1CCC9B975F445C9CB9AE5E84C706D99B9A6640489A78DBCD7F6F8
+ F47B8FB7F55E3C8EFFD52EB5F596148E66525D204AB58133BBF22911D3C140FA
+ 7BF7C5D6E2DC1918095817AD6DCC50BF275DBD93433E3226D564A0E67B3C18FD
+ 5808F3AF56AA2B463161216856426171E6894AA79C40DCF4DFDE0E5A75C74CE2
+ B62275AA27710EC6AFA8599DADD4D7E3C81B0F04FC3857861B453F40BACEC16E
+ 86D54F31B2A3EADA7A9CE2D18666132B8492A5A4C5D02D207D7E849C8AEBD567
+ 6F1BD66C67AC3BEC91B89896A73A9A7A10E9F31F6E779078337DF1F07A20418E
+ E95AFE32D8D960145E667C2BF40A681B104EA07BA371C0654FEE662E65B95039
+ 1E6CC8F00194205B57BC3C789B91C34B0AF5A378CB75A7CD48C620D392C76E8E
+ 794BB915DA16F79218AB0301D43BFCB91ECBC455170F0AE1CB4BE0F00FCFC133
+ 1BC0CA352ED0457F79910006E42DD68354317EB6BBB673B9B61D15F62FDC2F06
+ F9E16D30A9409E2D53B52F209A2ACD0B452547D2C9DC892AD13FB0D06FCFF33B
+ 73A9163E37A58C3F8DFF380B1590B9D15B53A04956C67FF1913EE80C16378045
+ ACBB2E57904D6FC09705B27ABE3BA548F20A08636ED6F4C9DD146CE4CCF79DF1
+ 3138723CAB34723B88475CB6005BBE0FFE0C951233CFFAF2D31EA8A17F1DAD67
+ 979A2A295F4870B366E4DE409142BAD9B794240BEDBB5B7B17CC881FB8A7C302
+ 35281318FB93E82C058D66574BAACCA3B0CE5A267ADB2B716F782987C567DDE0
+ 0E9A7D5AF211D8227436EFE3B1AF8A3A3200EA030438696AD50D572A773C6809
+ 044939C428F9AED64BD25E86391E7032D6B251AA28320F9058106505DD49BF13
+ 20E665494F5553789921D0453A1C701090083ED2D7D4D84DFA4A972241DF60AF
+ D28F8BA7034AD0E47F73ECD13DD99CF0C804FA756E0C45CF7F3737B046D380ED
+ 58A4194B97383A1FEE78B356DC6A4761DBAD5C27883E1EE374AF76656BFACF2F
+ 02DE4BF8CF77BE34204FF7487C3BC3C69696313E510D4C6C660A1FAD8B5F8115
+ 9909DEA761E1B1CBD56DC8B738D6BD2B7869A574B17A5CA6DBB63B35BBD53894
+ 58F27A703EEA3604BC08706A81A7BDFF23CC3ACFCE708492998B3B617313C8E5
+ B57B1E38A620211459C0C6E6A656A606C12B150C664290FA1F9DC3B5B4140C14
+ CDA67A8711026D3D2993E224132A0C83B2BF0C492FF5B08EED39325A63DA5DB0
+ AA57427B0889818E76AC6168EFBA1E920C785B67E11017AF39EED759C44A47D1
+ 92FFD4A7BD4289C94117B0B237B9277F7143AE814178F90589254FCCBDC69D54
+ 9EB152C2614056843BC44D082BA4C409AA6232426C97234752B3F02D8F015C51
+ 7885C3F8B34310006174718DFD699F2CE182166619BDF058F5B7E6C60BB2600E
+ 40F97429B56BDBD0EBC153D9223618D9BFD29E858BF3F9B10C2266CF27C5A079
+ 32228F526F936DABABC61B52184AB363F1E25D0ACA9391301E35F9EF86E3289B
+ 39AFEE8F6EC61F0E1AC584779B0299C9D1D35CCFA5FEFD392A206FC17B606277
+ 37D71880C92E1642747BFADAD824FC2586B9A0D17631B1DF42C75F5730D5252E
+ 1A38447BD53E03CD98A523AE78E275352B330C6E2FEFF2ADC5971E0940DFC723
+ 408277449FA4B72880FAB1E8E15054987E2F03C9DE44987156301AF17F12E904
+ CC8C6601AC2D0B1427FB21C5F503FF71C50AB3F305DD988277FE68AAD4DF6205
+ 0EFC7CB341C91D85A3AD6BD885E7AE7D66973B12F01CD9A474B60B9A83DC6518
+ 29456C2D3A65D9E9C07B556E04E9017BAB70C034B3A547BB8E3A94B7AE9CBE68
+ 78B2E7D18082355D8A6CCC55F1BACB26AB529090AD8FA49A4B591E4EC7EE871F
+ 09237221F745F2204CBDACC671FCDFD43FA2E9B4B1ACEC3263181606ED22011C
+ AB2B23369B31EAA2A6D17540CE250C30F01826EB1B0FB572A4ADAE5CEDE1D1B4
+ 4E86BC5632BEBA468D8BC1A9918D93945EF7191CC1BB68816D3C10A77CE59F4B
+ C291C9A13E57B704564501EC210CF27BADFB603B019AE90170A3A8C47D703FC3
+ DC4A73D9CC9BB16E6D4315A76448436068A61EA84972665F80C4E5CBCAD104C9
+ 6AA32FA73225C3C0AEF2CD77918DF0F3C549FF7B198FDEC2EC1908C9810976E0
+ 2BF522A12FC5418A5FF42542C737B4191007A5AC18B7E511042FADD6A5ED3320
+ B1F37D07CDA30042B6BC9D955CE336A6301FC05116E9E13ABF6DA2148AAB6028
+ 5B0AFBE6B6FDA2558728A02D493CF68673343E4A79EF630B19FA6E02D8646D0B
+ 44A35B315D93BEC5F6447256335ADAC9F2BEE7BBFC6D5F3267ED63C9F9F69969
+ 459B6140C75C4044B002C6BFD8E2157810F1927A52F079447714C5A77472120D
+ 5D82ABE9B1B175B2484D669DC38C9BD9ED7A296724C3F784BC1CE25167978636
+ 07AF10569F798D12B5DA37634BCE16D96F99222E6205A9E2CFD5575411D069C1
+ 57DF0493B2EDDA152EBD3836876331885F214061086A540881E770850C650360
+ B82A7D2FB2AD5465A7ECA0AF2BB93A0E9359E5C8E2C3FDEDA93325F9C8DA5DA0
+ 84CC12DF00B210E2DED0BE1CAD81B7D86CCF1E23D4BD65DA1E0F69DBF5BA19F4
+ 8EAEFE059CBF0E4F4C18C30E3419D746F6EE3A74D587457BA9A9F69930E48C07
+ DDDA7FA781313A53CAAF5942C8EF6BB02E4BCF8B37F966045810AC4EB6DECCB2
+ 3B55969A9BEBC2E67F2E747648E33BBDE575B31115DC526CD87500829B6B3D71
+ D5389B86C6F0554AC67D1183D77801FB1F685EDD3B95AACF1D88C74F10553791
+ B9980D27E54E047DBDC42DC6F9B37646DD86BE407D047C7EE48B9FD158431E01
+ 1EE68C465CAD17AF471072594F192481EAD58287C3CBD5E711917742BC0117D5
+ D5BD50E9A3610AB3FADB0230BD18E53AAAEE71ED3740BDEC37E4D4C6AC1722B0
+ 92607F0DB2631E4465FB341AAF8A49E304D8CF2D0456079A5FCEE9ED5C866989
+ E4A9783A08945A68844477F408E91FDB60AAF1DD8F3E1090EC6AE29E48B6E907
+ 3DEA2D73BAD1DE1B1E934F4648C0224DC68993BDC5DF04E216FA976A0DEC8FD2
+ 76893BE1391F164DD6B3BE8E6646921A8A8E32345D28BB29A7259B5330CE317D
+ E3841CBE2EAB7B0559115F51D9A47C75CA66FC11EAF82D5651D629093A249FB1
+ 145B5D4494531C05FBA01AF01724A0047720BD7A28F8CAB5F4740C85BD9C8C53
+ E9B9E50A013AE3F22BA4FF8D0BEF73E1DBBC5D91B17CF26A6B40A6CDD912ABFB
+ EC7A6BCD147A65AE5DEB76B3224D19C063DE31D85B13231EBEE598A12DA43629
+ 3476F2D4674CD10095B0CF0B1998CB2D9800634E176130833CB4E41BABE51EC1
+ 3E719FDC535972C7A4BA66DB02C42FA3BD13021378230C168CB5C0A99F56DA1F
+ 012B781A90A893B8E24388F4726E41106C77484DE00F90291FD1CBE480263C0D
+ 4CE0F1DC5765C72142E6083369D490567258805BDDC75FB518BBBE744C1B08B0
+ 43CE9A97FE204D4AD2EE9338B9BC9DA9816EB6F13281A82D33C3B47889EA874F
+ 6FE4E71FECF8D353309DB7ACE9C2FDE933D159CBEC2E4931751EC7B6A74BC869
+ 7378CB941521907754AE00D1A45099C953FB6DB514B5BECD1AD04FBD32C63E51
+ 867E4A6271AC756ACF3D7D5E8201584640BB465094BBE54525DA8889FF5BF4C4
+ 8972144EAA4FE788E97AE16699E929835612C1B426568730B4239BD820235684
+ 4C6342CBFBD98B248F8562BABBF1E47B2DB931A498B2B02FE095BE5724B70D7F
+ 17BF7338D0447B51FE77BBA47C651879792AC3CA0849D0582A4243E3325580F8
+ EA2F3380942F0982F3A8FE56EBA4B0315CF5DA02B759D1FA4EFF8C322268BAB7
+ 5FAEE7A7036262DBD90F47724575FD8CA683AC8E7AC6125B489ACF078705DA93
+ 081B573A4123B318249D6BE07B60483F663C5FBA5943EAA4435F8D4799D04768
+ FEE029EDB429D8AB292B86B5609198E4FAC37A6D2A5C5617CD8BBA58146B65E4
+ F98B48B90B2B487A7E54F6EB92718AFF3C938F0CCAF7C8F3109F53AFEBCBDC95
+ 53D6643D9E48905678B31881A2B52C6C79CE84F14CEAAF1BAB8070E84D7A8350
+ CAECC1A8CF4FF093B83A67B455CDD881F23D74B88D8D8CC45D71A88594C091F5
+ 73E7B54999E44FE856A87FBD151A6EB74F0FA0CCF50C8E7CCD2FD7B26E44C7C0
+ 8C399E67B58CA92D7EBD517C0D59B15526B698960D815129E55AE3B084E8679D
+ C0B05BE7F95170F41CAD5C772A0D14A614D74D027FF0843D69A4505D899915CE
+ 31BF09A4E7D4CF2721BD784257B88A782F46AEF82C521EA9D95421BE925D09FB
+ 1A0E3DEE49616BBF9494A033E3FE016E3E6AF9BC522022CFB13790BBA97C44E5
+ 6D91196EA867ECEAC5B30DEEBA213E422AFD6A80E76B2708DB0DF3E287AE00A5
+ 5A589E6E6AB2E132D8101ED01A551657ED2A728137B39B868AA1F43A874972A9
+ AF2FE790BEFE3ECF7D6E61FD0DBCE3CB44ED3B55E2EED5110B0AFF3B316310CA
+ D50920130BCCDE42E08F2F3C9E0E33EC95C6F0610B6B3DD382130819901F951A
+ 77EE72F5F5578D0C1D9F8E1DF0575D2779AD24C7585404FCC203ED7E51977DE7
+ 30828FDDFC02CF6B68DDB8E505DBA555EA89A61006D769E99B636E6942CFCCB7
+ F5D56123E39017D37883C28B0F4896CA1B9DDC08C5461F9879295AC5E644FEDC
+ E749A96612720EF05FA7B2E88F7B5CE1D18FFFFDD91BEFA8AE341851A917A02C
+ B869E0E51691CEFBB6BB6EF86B526A36BA36B27AB544720398E6A812951B9673
+ DE207A603C3DD021041C2C04EA4FAEA6ECA0653B7F71CFB7AE96A552E2556F53
+ B8934537758543B15A05DDA83292BD48E53D330F005F789FEF48B7B98CED7287
+ 3CA89E14B6D6568A98D7EE690DFFEE6526DEBE96738CA37E8DDAAB685AE9A71D
+ 7227463BAE2F48A2D96CF3F922833DDA2440857CB15F7ABFC4DF3156CAFF9B40
+ 49E36A63A25396BC2CF2C894980B1FE127C4CA549076CDB725AEEC0300CBE926
+ 791C4926AFD31A95C6841517E144B5BE81C02F184B22AD90694040722B52AA31
+ 691FDB7A8BD727AD842BC451D1D4F80C28A5543A228BF68EBD3EC1E16EC4FBAC
+ 56E6A2E89A89D42936F74C7CE52CBEAB4CD42CAF32AC0D0CD1E3C1D26C8AC7E8
+ E1B3F781B6753A27B6844A98F08DCD816049965283CBADD692F4BE30D5C60DF7
+ 1B6908F4A46767F363D3B5D5C591EEEB63A232CBC9E09550927AD2C9E2051E71
+ CEB893CFFD95CA8F2C5A9D8AB8599FB6DE5E23E73E64BD6CE1E53DA5979FAD78
+ CFF71468FDD2EE9369DE8CD71E72E3643BBE13FF28F2D1E07117C816CEFA6F6A
+ 10F758C3FC2EAB34A871D2652ACC41B2B15827982547E2B2E754C23F9A9424E4
+ 3A99A11CED5752081C27E1A8E0D146E032D5F9E1B5B9B0D10D1E330A7A3A4821
+ 0765469046904F93CF03360C2C70130A38AA6521AC6B6D56C030F8569260DD7B
+ E74BDC0D2A3A9F3150FD40AD21895D921439A9E0122F5B1DE51DB79B501D5D8F
+ 1D2E313246666B0E9E01B4E1C44FFF3C5F8B560369A733E752E7E9B7C0C50670
+ 0B1137105151DD13DC5531EDC9143B1520C4E8EE71B662DD9DF1DD61E0474107
+ CD912E5761F215F09A44808E457D54B67A7B4557436B4218C472A0C0192AB15A
+ B706C18A59525503DE1CCD543D64418910225299AECDFE2BC6FC195EB5D06797
+ 9EB4D6552CCF989A551FC11324297CCCFA87CFB6B853395BA7FDD278CCEED65E
+ C1FFAF7095B81E62B06DF3CF439F3775E213C1006C30C3F2F0182BAB02BAFB82
+ 32A122E6E9562CE25173B06907E86B7CD48B06D909254B6B4025701D484402CD
+ D4600875140F6E4219D7E2F83E297390AF45A263A9058A72C0E0294BC613679C
+ 056AB3D7092148FBC84455BB2D2AE49E707302297BA2EA2D0E9D214ECE3CF912
+ E4CD5B37341B5A8E07BDD264A3762DC083F69472C44E95BB815A84BE3EB69819
+ 18CC114B9BB89EAD6DC4A666E83523C2204AA3D12888060ED013AEB554C70282
+ 45D9780D6FFDEBA85C4334564E4C1DC45142695C7E6D7DE15499A323675EB4B5
+ 3BBEE3B242DC7AB2493E700B798657D0EB6CADCAE3115995C34D37CE738B6E62
+ 2EA51A980C5EBDAFC71504DFA8BA89530B2CA718443319454731D0B07BC2705F
+ 8697A808EF034A63AF1786B3BBB172D006194ADEE7190F43558696FF6EC3F6DD
+ 5EB3B5660DAD5DBE2243F9404E84BF2999A14740F759128135A6F222FAC1D74E
+ 55C146BB51BFA13CFAEAC22250CCC7259AA90F5EFDB623F55613ED2D94FB71B3
+ 28189E27FFA3082A51C19F044F23D3BC2BCA4DD541C452675D5C6B76B3B13948
+ B380447E80C68115AC76689DCAF649488B9878C1F6976001DAFB50ADC2E887CD
+ 1C61BA9BE88BF3CFFE5CD34E3A848380F8C0753552C9B774C4A09AEAB0669D67
+ F894A60BEEFF2343A36021CC80141EE393202CB6CCC262A04BE4D3234CA9F77C
+ ED491EF6D642A94232C2F562A7E1C3E121D3092E9E6E7B957D06E8A32BAEFCFB
+ 580724EE47B21EC522D7D3B9649D12074537D4138E3BB8DB8DBBF68FC34FE73E
+ 97A7901EC3A24601A0208AF39894EE1E777B6B4B7F253A74ABD7379C61E79042
+ 1AC717685EE80C6AE9157B21492D3638E2F4098C504AB4A88749771EA3A3079B
+ 61FE94FBC1733D924F35F0D29694025A227513062FA7BEC1052C4660D6F228F8
+ 3D95D27E9EC976462B77F9E399CF51B4E301E8737A6700961C2874553C3B74D7
+ CEFF316B6C0EBEAD6272A381A6490440C4D41708A3F4506CB456E2B2BA2790C3
+ EACDD66E69B5D0B6FCD6127A00AF8990F4671747EA1BE633EE8D2260F423ECA1
+ F065172A5E15597D5410755F64713D4355B38919477AF585FBD45AF51E9399E5
+ B04FE7C101129FE6EB8B3DA549BD1330F031BAFF185BED4AFCF19BEE84B62C52
+ 9BB2824CDED69D0FE6E2FBCF0D8530E65F471E8FBBF8C9F27C37483FD182E7ED
+ D368B833E42755D6D6E1B6635620F679FE91D03D59C49919F6A55D626267DD72
+ CC2F504550F6F981AB012AED8F52BF32BEDEDB7E93CB60935027274D9E881BAD
+ 9EA88A2EAC9DCED200AD3E7C4B2DF7E0350FA81B9C3EF2671F1C7D6D7F8CC212
+ 17CB1AD95588E6411440FD86BD77AF8A2B76AF84E90FC445BCB5F291C60708B8
+ 83FB4C105E0730BB55002915BD0F6A37475A5ABF0DEED9766C7B01C9F9F1FB97
+ 016667B671E27B184255F166DD706E4A9E15CD17F9B3D437DB78DAFF1A59BC4C
+ 2697A48AEAD6450AAF7B1329EDA83EB22C9BD4E99BE13B03C223C7B1330026C4
+ F5081C3D89EF90D2AFCB74C795DD4A4D74A8BE564D87439134338F09A401F9AF
+ 97C67E68EB9214D88C33AA3751821CA2724B829C0B76B4B00FD747126D38FB9C
+ 438A19DC2FE3AB118BBE094C073B6807FA49DDC38B5FE5FF8CA614678C6CB899
+ 53A1B4AB5EFB004616041804D8E481441D37B85C95A122BA6505B5A7D870822B
+ 65CB2E9F84DA5EB4C9AC7A1544680A20D3A296731C7911499A10BE8791F36256
+ 619BB3B8FF74FA59F6CA9EA919532F50D8B6AAD67B113A3096AE5D7943890233
+ 268173631A7CBDCA2610DA2C806D4416945D48ABA3DE5526F13C3B12A1F71FE5
+ FB3DEED8B537854440DEA3066D784B2256E3B045F03F3DF1670825ED4518ECF4
+ 355FB19AAB338D8802A4AE94C82903484D47AFA7AD94B7C68354DF4ECDC218C9
+ 9C5CBFF9F7E5657AA60FDF27AAD94E6788918D353DF03418161B9603C83E3A3A
+ 2819C17355AF45B5867A0CAB005B3E4A2A76E511C96D579FD0FEB976F64EB7EB
+ D451840C3F1F04C686B1EC4E10F163ADBD0822327191E905523F131DFC8F7D13
+ F5876A0B4B35402863572C119102EFF5A77B993E38EE6352C3477E4C2BFD7A35
+ 4FF7EA1DCB0C0B8BD0B35290D75D3CADCF0C8694F6115339753890D0F4D06525
+ C7425B7C4A067C8EAEEC7AAD619CD4B17BCEF426ED0A372C12EF3A0395C7F420
+ 9E0ADB6AA214AB9048C824422D504DD2424D0FE6C5F117D8CC18713FEA1C4CFC
+ 877CEFCD19888E745DC690F15BCE31A93C4DAA93D7748F48247D08D4F24BB915
+ DC40CD9748BE6DC864D8A300BBE96541540272E2A10EEBEE2A99480A3BD8E801
+ 82FF8C6258954543A1842BB651F3A732126835DA782F7A4F22748E1733C27204
+ 736FBAF1718786A767E3C33BB55252F204AE8C5412D1496989A1D340E0F9DEC6
+ F26D88383D8D8A8A6AC1178740DA44216044BC06241DA5608F8A4FCBFCFB7FAA
+ 083A62EB381D80CDF0F74C8582C01B4356E3BA50FA11C84D9861D079D0955021
+ B6E8E8707EDA91C9884F3D0F28F8F55671D26EFE54D439A51E232B19B7EB3E4F
+ B422FE499CF567CFD7D3BC048113C8D68238065ADE04AEFF67534FB84C3C9CDB
+ 00A28235FE9645C03A045B30CC12EF2CA6A23897AFD6F95E8A0049A3B3853277
+ 7553CD0AE1CB7F02465E48949ADE479AB6EE5634EB4DF718E72E33756CCD1B11
+ CB0549F7C381765606C9F67E838AA52AA834B5EF8D5C83F896C315F0E07ECDD5
+ F796265E2B2B7FFE897DE63FCFA90CDADAF3F5485B101F28A7F12C95A186DAD3
+ 7FE8B1F81C48C7C96471C40CC9149BB1BF4804FBE4CEB5ECDF1B7C0526BBA75A
+ AC92F0E806962137CFAB6070C1277399D35B1BFC7FA87A2E45E1CCFD019BD940
+ AA784F92536367A565DA87609EF64B2D62973DB97BB8726FB12E0BDAD088D585
+ 247CF0E1927E86B7528C23E9DDF6B09DCE8BFEB00D9A80BD72D7723127FCBEA7
+ EF2453340B92ECC181710CA2B567F147C816812AD6A8BDF9E92E4E6A7C3E1409
+ B228B7AFA83D07A557C7FEA6F02060D3A756B5AF0B0670A80D3D53F283450F36
+ 3440586F736A79F4F53CEF576857882560A4328056B015A07A2F3A8E9B51437A
+ B0100CEE2C33EAA9700D38E87B258AFB6301F191E89DAF94A1B9B45A1644FDF0
+ 8BFCE93192E7DC9DFA442FEC1F70281C90D660294F7D7BE0294759A51367A6B0
+ 7AC6AE5C0E6BEE2BCBEC1FAB26665F550BA90332A14DFCE7D417FFEB0B32B410
+ D889B7BD6BCBC11BF440DAD16C61A23AA3DC66B89FC87D8F46F5C3730B3715D0
+ F72EA0FD83CDC7316A86C29D3B387CC1EF4FF946A1CA97856A4A1A4108F59ADB
+ ED76CC324B3CEC290731B4EB84B5CBB387339436D86B3292FCD7DEBF0C9BE075
+ C3428150D1835A732DDC0CD4D388940CC306729E54BB765826E098DD013A4255
+ B1E1E963699AA1211507FD8D06626E483CDBDE11A0E4373F25757BA391B7B47B
+ 4828E3B802D25F68EB2EBCAECB7D90F78D3D7DDE5B78DCD996FFAC9A936BDD12
+ 4FE7A9F027ABB30683DEE6559ECED6E01F18EFCCC7AF89A4342F5A227A448C2A
+ A7242371B7EC393FB98AB146B66D5BCF219AEC1890AC6784B5D1154FCEA5A0B8
+ 031AA33B6FECEF9C0A8D3A9B2E50881DA0AE2157B8476AC4DAC420688C954056
+ 4B62663E069953B4FB25F27FAEB473C65B376E4757FABCCE2ED5CFFD2914CAE2
+ 60D88E25973DFC3941DF4A561132F77BB099A82A2D4AD22094E536C8939AE4A8
+ C9E0E5992E5968656C69078F1D4B496D90838EF763A4F31748DB4FE0BAF1184E
+ 2DCE23F70D9B56C19B8B66F86AF41C6B3F6B092441F7A366F30F4D2AB81FE676
+ 951B8E2D119BB4EDDDA41CD1182DDEE37B0E9E4E5C0A71A5ECD14A36314D4F9E
+ D669052D65F326E1C590E28A7CA45098E1863A7E08C539391C69DF85828E2F70
+ B0B01DC7E0CADA18495E4F7073522986D09D4C8E674F378E2070099FE6C2CB30
+ 25B76D58CF089C087C6DAE42177F715D08034CC83889C0D7C0000694E38C33C7
+ F7A88E8481C85D672947C6CDD3A367D7F8CB4A54744153A01C1BD03018451721
+ 1207A6FEAD35D2074E215D9EF365CDC8D63DEE7B170BD35E5ECD3E1D51BD883B
+ 6FE707F15D6D3C35A13E0218832918A6EDCC3556343EE1C0E9C7B5AEE7A469AC
+ 5C5FF43231C6B3F0AD0FB607DDC5F6D79F28CA343E015B3D25C744D1A3025D2C
+ F92B7619D41B096528BC3DE3458520212B718937C4DCC0CAD0FC17ECBF6446F7
+ 0A968B971F1EEC2C0FFFEE47D96334AD735EFB10C6F5165E17C33403FAAE3479
+ 190172FDA6FA81319E76E22E9C8733D34E9E8E8BD06C6F7E91E0A6E0D192519B
+ AF1B2056DCFCF5621BC853FBDB9E466BEB4C81533D55502FC3D74CE0C3ADCE2A
+ 7CFD54C602759E7B358CCB8AF0A25BDE8EA2775F3652A8AA46A1EC1B7A055681
+ 645596C405AE9CD95952F94CDF8414581F9A035341CA3822B8F0F5C7B5AD810D
+ 7EE95A06E5747166899ACED3EB13477E7F65D25C95557B726C9E77FEAE4D9792
+ 8CB476304410FFD539B48AEBE043EE40C585803778F99EC3E07882694B9B1F9C
+ 2A746F55F107F051855E7B5D100C79647DD9AF64F190C63F793035274F1EF937
+ 1745A8B10FC074A9FC4E39A6330AA0A96DED2945F423EB437CC14FB5DF8FC1B6
+ 93137CCBBC32ADB31D0D7F9A397116EDF33CC9624BE22C04BC854CA4872A9879
+ C6AECBC9FE8518D3A798E6C3C2D73236F97D8871026C9DD24E3B122D3C0E09D8
+ 558BE7D379EB8E294BBF7E588825F1BDD3E77B2CA357FCEC8B16647C126145E0
+ 59DC2DF8415C68ADF553C635D6327330636BD0D9920657E7AB0BA4EEC69BAFA2
+ 1A96D8B86422B9627541219453187E80946C1AF31B95757D544B77E5372EE2E2
+ 0D63AE911BE1468AF3858B84287150B1013CE1145ABDD8733EFC4902D333DD6E
+ B96D9E78EC0235A1CF383B1F0D41C1EFAAE2351C3DB3616DE62B84542BF9C0B0
+ AD4A59CEF2E54754F46DD351AD70451A18A5DD59C3B4156DD1C26514165F6E18
+ 31B521324CD5F9A36ACDFDFE44A9CFBC8812DB404B3B04A2611CB14B141E908D
+ 64DFFAA0D7865E81F3F2A45D4763319893E2E087304F7DB2ABC13E4F5B8CBF1B
+ 5AB8AAF374BDA6543DFDE44BE4EC9830B8EB0FA960DA8D38733887C80EAB5F7D
+ 1E72C61CDB990E5309765E76F672D606D5AA6CBA685141773C4A9C340B5DE2F4
+ 5F00F8893E076ECE44191A04740A6D54D33D86EBC3753EC25364C59616FE666C
+ 6829EABEF91EDEDEEA2A62FBA2351FE69FD23402EE69498EC8C2EB06CD293D0C
+ BB58CB2391A122E962D78C966E417977856B4A5A12099640CD932DDD4F68FEF7
+ 2A39532585C34D7C50619D436372E5E7D4016667B3749FED0E06B5B4E67061FB
+ 2DB4B03C6D3F2D42AC1E0088F9732BFE26D57E5D11D90A0C41074FEF204DC6B6
+ 07C85C36EB335B86A96E1B5C40746B5F1496D738BFDDFBDDF3001C1934AD5AAC
+ 5F58637A993795BFD13D139D227DC2EE466F20B0B796AE6ACB279366C9AD771A
+ 59B056327753182CECFC5FD83257BF44FBAC3EA27DC533B387C2F54595B4FA43
+ A868ACC4B09EF6FFFB0DD79CB5BF2CAD23AABB9B8C104D5468517CC00CBF049D
+ DC815BBF32DAF5EEFCD14F3965226D078C6E761F4892ACFCCE7E187E4683E3B9
+ 4A89CF51B91089F5179777092F82015278AFE7E5772C5CA5779BDAC1B4238F6C
+ CF18797B8D6E817DACBE083EBA3D888D9B65E024AFAB66E2A2F0BED73279A1C8
+ 37ACFD1833C26835EF172F5E2E9C51DB1F50DBD1F57D303C616B72EAC690532F
+ 2BE287C446E2BA6AC8C6C040D90C07986264AB41007E77FAC48FDA9781A974CF
+ 5F829D7D147FA2CC89AE3EF8216A9673839BFDB33C5E74C1CAC7011D615CA214
+ 14F4DD38FEABC6C224407C62FFFCA58E49C6FC64C275618AC8A44D8AB46C054F
+ 48856FD08011060D4A582134E960AC487462C4939EE03CCCE9014C0D7BF12251
+ C996BAF098C748CE041CEB1F969527C9EEE6EDB1BDC6E838A2A2A10815C6C612
+ 8A4728828F488768347ECF8613FC1509BF3228AFC8F2F49E38E1549975B43C5D
+ 781DA3F09A013B267FBB9C60CD9BDF401F8B365C08B82CDFE63FCBABA05B7FE9
+ C399CB5FC5A63962098830451ABD107CD734358E48DF4AB5A162C45596BE54CA
+ 7A53F5F9EBFD2ECB1B220125585E70CA4A49327EC5FEB59157CCC775E1184B3C
+ 1ECBFF5331C7E9F32C8D2C9D41D06A22B36E1499989862CE5B9B035EB384628D
+ ACAD7456125467C0D9D47062ECC99FC78B3B02A1738FB27CC6904F33B750721C
+ D19EAD93A105B6E6B7BB8518A217916EF11346FA2D9DA68A011B8E123280B4A2
+ 1398CA59FAD1D21983D111A683663C1631B3C8A295BDD82B08D8E20E0E3EA480
+ 0116F2875E4A4DFDBB277C1CBCEBAE1660E744AB1BB8FE1F856DCC6488773EA2
+ E12B80A98A326C630098EBC2A3D9EE857E37CDFCDBA7F444D32B63031F825157
+ CC54DB1F3724DAA8C1EA78FD6D092481500BA5B179BB7B07E3584A026B706F6F
+ AA836C71014D9F3CFCFBBE208817162E520F5DE20F4D0B02AB2ABD1DB8531E93
+ E64D437ED2B860A0E72D3EB8DCDD8EF14F448B7F4E9442F999E323F07AF1A3E9
+ 529D2645DEC9174666D786E9504D8BD39B7CFCED7E84C98CE8FEE2B8724A83BF
+ 231DDF6A0BFD18C27E144F81C8470104C2CD826E3939BDADA12C5DCC9148FB6C
+ 93A83AD850F95CB3A27AEDB2A71D71155524530CC89E6535087A02F50FD42E8C
+ 20108F9B0694FE8435E9B8CC2718AF65A3CF2B75D3EAD06B961D90430FB0BAB7
+ 14AC7804378C2DFEB91715FA7B2DBE924DA968A811EC79192F2BFB4EA0DF8B29
+ 7229ED4A3939D68775B8E7C5DA7D1CFB6D39430190396D21E4D365836D35484A
+ 05B685C1792987AAD16C81ABBB9AA65882203756B824530579680773E14DA47C
+ F7A031613624B3C3E763B3F70F4D6AE20BB6CA8DE3E744F9A7E50AE74590515B
+ 90A48D7A890A299390F04A93CE1C3CC73D6F60EE9DD68560E94818AC18C5BFC3
+ AFDDD6F07A0A4349628241152D5A736E10A627399868E8F4334AF8EECAE90780
+ 05CC98AD74297E7F92E16A1F0930FDB8EFBEF7FD4ED8C95360A2C0754B1B05E8
+ B6568170F0071C17FC2A2CA20CABFB791369EC4FC19DAE22A4B166A65AD6AE57
+ EE6AE1604FD23E47569F89716ED68A673449074FD42712A95675034697421CA6
+ 8E8B33F113C45EE17AA634316120B5E32A8633FC9FBD217732F4C488745A21E5
+ BC93F56EB29693A6A7E3FA64FE3708A171BE18F779754FEE2F578E7018DDF7BA
+ 882D587E3AC376B7CA31F55EBDBE12B991A8AAA067EB6E38ED732E3A4EEBB5E5
+ FB59214FD4D0B8ED64F8AFF7668859C5F12E27BC30E64F83CFA1CA137D67B04F
+ E3DD001A91D3422C8F5A570E5E2589875D8F717D7783A617E6B157E4711AEF32
+ 161AF4FC423FD2EB71290716CE93AA53E76DC1CE2ABEA61FBB716DB769E76FCB
+ AC85CCEC0869168009FD1128A63C9D5E00E02A8FA05048B294DCD94AD9C5C465
+ 87DCB6E28C0785C0E9D82E737F44AAA85F993D9EC267F4955B1E81D90AFFA1B1
+ C9E5B3341B279C6BF4816CE369C82F215C9648F06D76AD2C6BE7E2D6119978F9
+ DABF6B6BB4D7B58217E2D279D4821921FEB8FD0371170E0FFBA9ECFF863D1A6A
+ 185638ECA4AF9251E0DC23E9EB0D73A59EFBD69F468A8DE88E309825AC8936EF
+ 4B2C219B03319866815A324EB1046389881B6EDA68096450748399B896E3C467
+ 28C646DCD471E5EEB35D015D5C0BADB49E0C1E840B28E9D75D9397D73F0DD92E
+ 998A4E77B806E2AB865A2B8016489D21191E62F07C1F9076408452F0B5BE2BF2
+ 9130685F31995FDBA37D5D79AEF0EF3DC2C81267DEB1A24E9E3568E4A5ED4E37
+ 75CFF5A1B1AA1C644784ADC41FF02700750E88AC25C54F821064A39434FE4702
+ FC37190825E7C9A235D11B5B06CC2EFF0206F457C1699FCB798CF79A44478190
+ 974990E2667BD521852C65B57015D6057E0591003C28842CE7CA667F1EF8F802
+ E1FE50CF7F3DF18BF7CF0CED44FFA60D7C18BD11AAF83161567DA45B4F0147A4
+ 67C26D9E5A99845E26388BD0317783EA55A7B031D0C4C6ABDE16388DF340441F
+ 7CB9A5EDD90363618DBB28357BBFD2AF7047A98C5ACE8558415A6626AC85769D
+ 3D54204D60D2D8CFC7DC01837F4D6842E4F514348E570588AC93D23BF53586F2
+ B18B63997F5DDB319577A2C653A97C2E417E01CDD6D85956E66AA8C47FA92EF0
+ E52AF1FB5E69D1447C9E6716A726F5C700C585C2ED3238CFC04EBC23E9025862
+ C899CB4F7B4162CA328D0060C6DBB48E4ACBB1708241A9A9E7B4A0A7C1535D69
+ BEA598FEEBA5450A157BD7E03210504B7EE9F6E135A1651976DDDAB79951C9F8
+ A0820A7BD684C4F19F486AB6AFCA05968F3D163F39E449A0804F91C83B985AFB
+ FAB77637815D7361C52A0CD21192566B78D1E54EA968E71A991130305C67D906
+ FB27661F78E53C362BB3F07C02B091BC172B58F153B8FED5777F9F0CE15B5DAC
+ 966AAAA2F1FCED6A4047CCDB680BEC836C6BCAF3402512C9F58CA45EED94E8D2
+ B237A001AB730320C66EEA3C978173F835E1124B712FFBCE9BF80E1C89D83C6E
+ 05703FA6C66208C62A1EFE7DB425E6DD3A92660A9D69A89EE90FEAADDAF7A575
+ DBE4DF06CE490B471A2A1D8F5D9AD158CF3DA9F116269B8C207713C44DF30E17
+ A17E9FA81E92A98E8E97FBD3A74EE05508A09CCF1E1B1A619635EC9709DAFC41
+ 7A9A640551AC8DFA014FFF047EA045A3A965ADB1AABBA76A2FEEABEA181571CE
+ 2FC8CE740865D9F9E796C2EA72E392422FA85DE5D61EE2B7DC1E7DE2C78085BB
+ DA4E7759C09ABAD37E3AEE7360407F62C6B5E2E31AB729BC47C44BC0C86D1F6B
+ B1FB01143C917637F279E0CE0A0A391FD231BF3049016C9E8AD063C6A03B33DF
+ 8F1F7A067F034CE1FD6551EE5E32947B7769CBC9142EB5020AC9FCBA8E9C286B
+ D6584109ED3F80D44D79704DFAAE4E1A58ABA270BE1833F50D08CD000D41F2DB
+ 8A4F8653720C47587620C9FDA0085E83E5C92BC6972D834AC7E13F092D327B00
+ 3907425ECF395A4FF64E3307D69C7BFFC62B0B7BA419FE66FCDC6FE3A1EF6CDF
+ E0D71C03F877D0D4AC69F52F4853304B22DD7778FA5ABA3E7CCE184EC4AF2D39
+ 6A9201AA0F0D5E31555EA390AB67BCB0E02E326FEEFECFB3D39F5E5D5B18451C
+ 422268D713C42DD8484FF98FD7616CC8337C0EAB8E9F5C424FBC382238095D0B
+ C676140E5927AA4451843D4CB99B8FF5275F019A92A1C0987D3ED9816B1AC918
+ 751C2ED6D66552BDCFBBFC47235ED5B937F6321BFBC7100A7CB909A45F09E817
+ 761FA99243CF85692B0E1D8BA741D3CF6FBFD48A4284A4FE226A2198A342BF2D
+ EC5220B69BDB4B050C1CF8FD58C1AD164A6F35946DEF77E9B0BFAD268FEFF5B8
+ 51B75790EA15A5FA71B38F96C5B338026F65F9704333637FEE0AC7C47D266623
+ 05BDA560FAD569B7409CEA12F1A9FBE422B06E17DB3768050E8E9EF4909CC725
+ C3239F4A5903CB56D47885E53C75991FB5B689C6E409338B210326DBB5E7CC84
+ 2CD091E985CC4FBBE2CC9C591DDA9F7DFCD3DDFCF9C27BCE2E8AF178F63FADAF
+ 9F699D64BA5CA916E68E2842F5B903EB3C3E4092857D117E2822AD2626F796DB
+ FA3C5BF1D3050A6C71E761CE402ED431F5A7C269B5E60587EA80F6629D41B9B5
+ 10BA4916F9CF36ECCC21A0A369B3629480D165033E5D86F3694BA63F0B187FE5
+ 2C63AC78F637A9D44D741E9DD65ADE7D183D6C95D20A4EE490C23A6D78F9E599
+ 67E212A6E505E03E0B341A7A99D24F382E147CBBEC2A78B4081A19E6198041D7
+ 676D5EF5DEF578C26D0FE8112883FFC39734EABCD3AF7BA6D100827B1F2E6111
+ D16CA49833618B180BEF66A5D97E57CE2CAD54EECBD8D118FAEFDC706D744F65
+ 5CEFB1206B7B290D630319381B59AF3FE4916E63557B98ED720C893AECD5F71C
+ 9F274BEE4936825CDEC55A9957EAA9279DFB8199F9DD09F497EE1D193253824A
+ F7572EDB3D914C7DD697E43633E7A3B9081D98A4A64C01249A6028AA37691964
+ 5897EF275DA4BE5112A4EF496EF667A15595E27C8FC61B3CBC567573C9EBAA10
+ 17B9CF8073B5982FECE65672ABB985C0B1D9EBED2BCA37B344A4BB5B6A3AE494
+ 01480092B3F30C8A5509DBC6DB58F6B427560581FBAF5803AAE0F7A4B74ADC07
+ 8B41E31B1F0F1CD93315A2C77F23B30C1B93606D6426E1C06084EB2066478DD9
+ 725BCC43941122951F5E41964C49F3952B2BD22A8B28223AF3BB4C0A569A8388
+ FDE3103556C958FB3131FE3B93BB1E0EA5C6E6B4E92C023989A0036C5B642B7D
+ 8BD827E9086F05D5F2D4821760C405F80E20046B2AF826AFA733EE66DC66398E
+ 4FD5E34748396A6725A86A40F38E906C7AC8D5C37EC9C4C6E6E7C755E8088B4E
+ 921EEC2A6B3B82DAB9803C5EA1DDE8C85850FB1B30933AAB04095400455A45F2
+ E2B3FDAD746FC66FF404A0BCA34256B90C1587FF9D3EB87A7983887B931E550B
+ 443EC203EF5A3551F54618E08B8CC47BF37B815FB20E13778A53FF57EF41E203
+ 4636A231D12D7CCCEC3111192C27E62F87AD9B3A33AFC726B8F1E8DE527CBE4B
+ F1F488DCD895CEC8D7548803CEEDE90A16C8B51ADA281755172044D40DD82E3F
+ F351C56BFC59B7B819FBAD34C50C350F04A17609AFAE08422AC6627F80C71502
+ ACBA87DC6E5F3098EFF82CE7FE64F40DD75C7E10A383D97BB5559E0B08900C54
+ 53F04BB45BE1C4F0238389079B501D54DC832D44213F599445229E184FB4EF74
+ 28A26D3C6797CD12CCD79593649A938B650522E405D366DEBD58A212F9253E58
+ 7C9BBC02B06B1CDD264B4F6F900CAD4D556953461FC08015D67940C14DEDB922
+ D04A847D4D3165875063D163760CED8D04A14DA959381FB3DAC024CD36FEACCA
+ 8CDA6C3C3BE761169DBA0A1C3599566B050C97625D37AAEAAC5658B58C768198
+ 673628D68A7F19FB83BFAF60493945574F3489D112EAE1ABC098B67E70E73783
+ 9BC0C87383A309802DF92FA3DD2BC8973F90B5D9DAF3C1A9F0F3D2CD37CBE447
+ 3EE5139910E956E80A9E9483FB419F761B046989F5149D3B6E03F09A47765E99
+ 4E77C0E4C8441601D9C1E9D4E368C537A3C999A6CA819F19979F341DCE36A3D3
+ E6738A9280C2E84466C7D84B626DDD71B68015BF56F517D920DB4612ADF55D3F
+ 6B2BD37E4AFAFEBBAD89B682428BACA4F91431F35284BF5EEA1C56965D348B19
+ 005B00E39E592A4F745F8AA28E4622346EEFB56729D68D6C7B9E52956A3A9926
+ BAA8CDB9F4D5907132EC8C37C3ACE2F9159A8FE709850F78D81272AFC34FCF13
+ DA60A5DF37299C47A6FDD5F28B873652D4B996EC3130EBB96DF1089D6D2280F1
+ BC85F0CEEB9C1CA6C47537696AB610B41FE059B4A780A6EAE25BA24C26053F57
+ 02DC4D604CD2B8CF6242F013ADD77310414D13BBD9391B62C96E58B0EF544EB1
+ 8A7DDDFB30E63C4C1AFA0BA074226AB52FFDFEE18E306AA20E826F43F96CA4E6
+ 311116C999A60B7EA4DEC6DF45CD8CAC6BFB3F8F79CCF788A2A16D7BB1F165F5
+ ABDBD305F8197943AAF1C145D457B52CCC8499BF0B88B6E00EB23F59343332AC
+ A610EB22E9A25F254E5CA730F8A2AC698648527E8558F9D9583A8A421CDD3AE6
+ BBAA6AA8CD28DD62A66E6E01AE145626515EE75814365F5CEE57840C85C0A6F8
+ CD9B79E0D60272DB9C3AB29EA55EB84F859F2C16FC26EEE2F50CF6F119576556
+ 2DCE29901B8029E1776AD7B6947907B2B8DB6FEBF82EE581BEC32F92CE1A70D9
+ 9E0C94CD0D425E2714EE3FA2AE4DABB57B02C4658BBDBE183C7D1E061D89D078
+ 7656887920843FCE8B3F1C7C6C024EC327F3AAC42CFB92EE9C8ECC6F1739BC49
+ 5725DC5E2B35430FDE38C65E2FDCBB80D70C6B9E31CF30FFE9A566A925C3CE0C
+ F7FCAF94DF4DDFBA171836F19523494809C619CA1E40E77344A2D1F4310561A9
+ A170F86343C3F075531A5DE073ADAE2FD72AFCB9B79AFBA5B61ABE2906E54ED1
+ AB6D0A6D64FF8DE521360DCF1E0FAD873E3B9BFCE5A1168D1B22715839A41E65
+ F7ED1B19BEDC13C4003BEEB789B366A7005DC230FF34D6E20066FE23565C3C13
+ CE93EB71D7149D088FEAF7DDFBA0C517B11371518E2B2D10CCC210B896B8DCB2
+ 4D0C4B27BD52DA60B7543D318C0A4A85130C23F1470D2792622303DC6DAE8FEE
+ 46E1FB5C0DFDE810C646D152058E610D9EB27DCDB14A19B95466DBAF21D1992B
+ 9FE3237823D5EE759129CCE4CE3C3C9E4DA19DCFC719509BECFD18A34EBEECE6
+ F079C2B51FE6E54E73CFD467AA687380662234D1F2760BE395B829E017EA845A
+ A09A4C138486A36A40D2A56E6E34E85B14C53E3204399EAF1F965E37ECCAEB63
+ 4DC940765902BE6838CA047AFC0966EF993F3B91D0C415F1CB3791C9A147DCCC
+ D3C989905135E43BAC4F3B4C99697EFCB08C2DEEA9C2B3E2E04963B8185DB8CA
+ 1D843E17D939A4C38E2A490169C1C150245F668B8B297C620136BF793FEC1AA5
+ 015F8570B33BA5F09FE99EF780B38CF90FD7A3F2B77721007D23EA78C69736B7
+ 4F85FD0B353FE684D496822FB8D361F09A19EFD3B02AB39463106E96F26D727D
+ B7FB50744DEF6B5FAB7B23DB7D4AF4EF16FA2D7A4FEE0792E6A63DD6D026E447
+ 0E8ABE5048CC9B149F6FDC58CB8476F9C71E3FB9AC39DDC1FCBA473DCB725E66
+ B961D4833DD3AC57B313DD65C7C58E9DF5C41DD4466D8696C75DF2A8655A0DD3
+ 8A8E0D7A1A75F5B1414DFB4CB834AC984E5D2AB3B0AA3ECF61F55EFB79F44759
+ 6C854322B6E1599784B32E024773263AD3AC07AABEAB9A25A41997F9E9417E44
+ 7C2E046EB194F46B43B0D976B55A392C0981AB99A0DEA04FA0BB1EAA3C7AB275
+ F96F5435CA09696E8D56020566CD98B657036C3417E25A2EF949F2D92CA1C591
+ 35043D33071449DBE720F1E37E84106C2B52C4AC8763C756EEBC446ADA164B10
+ 6C3F6B13EDF164FD5A641F2003671F5CB532B07C268B48387DB10E7A27FD85D7
+ 969E9C1C0F86AEA5FCF391A0CAF95447534DCBDD4B5502A049A9464946645119
+ 8177E0A3880587130A0C26453DB84B2FCB207953FA0850845A934F5AF8B086FD
+ 08D8A77B3806B15CD0A78D23079999D10FCD563841725D33D4AC98DB27B5117C
+ B1FF79282CCB5FE81892FFBA6250AE3019739388576C35D111B380CEE5C76CB9
+ E7B99897EA2A4540D90EF41CB43405D762B4DD8572F31886CE5E0B5F698F9A7A
+ D1C840657702C8EEAC46B9CB83E2734305BD3ED4E877C200F55CCCA1B616A8EA
+ 1C8A002D9A81A67BF828EA9313334657B53DDF0CD2753C3192099BDE5FF6C3FD
+ 5C40FF15EBCC6EC3CF6CFF3C2073F763015260F6EF080B8CB8A2BCDAF2CBF79C
+ 71873076954386AC60C0100B3BC880AA9B7B38417E2D57B6A8D039E31221C0C7
+ 9A69D44089E73AAD83B614590C962D64B4ED11863CF2AC5ED0F1F599E7B072FB
+ D8EE5A0E2CA76BDA290D7C91B1F8A811DA8B7024DFE5864B5AD59B0E49DBF699
+ 10329AF670D8655700C289091AA499BF71FF3161535A895C66A200973910C9DF
+ 7BF4EC97A84C50ABFAA5ABB8AF1F543E4D9CB93BF0A54D49D3D3AF02122BB3DD
+ FB391C8DA46E405803C6CBC6351753D9C2D0BA37BD6EEA7D19C163814A954997
+ 66569A0B61E8CBA6FA05116B585D4D8D87B5C4A6BF41140D591DCE282DFE8C9E
+ AF5DB34BD2931B8D111E1FA9418BF320B6A840B27CA9434B68499E78C182EBE9
+ EA7825484B59619D8520164D6418B1E79A1584F4C39509E07C288F17DD55FFF1
+ E13845919C3034BE7D8814B19482AEC0DF51EA069180E2197E72C53097CC8EAA
+ 83850E437A6AD4BF8106857A5CCEC87519613F9879121234412725332AB3D4CD
+ 1E7AEB224C62A392419691DB4F7A10284FBB2E8588CC7523127FF2CE367CF740
+ 3C3A095EDC71074D0568A7B8610594FFBB5726FA9EDD0A89BED44D5C5B88BC32
+ 4174499FB891B3111070F616A330359A70CC6ACF5897A6B9B965E7CEBEA4F63A
+ 4E9FE6A59DB12875C348291B10A969F8A2F9B6F48DEBDD08A15CCB736E5CFD97
+ 14F9FF6A3A01C7064732A7CC012C68468E365C8BED96294651D4832ACC102478
+ ECEBA3FDD4B82924A6E6FB047F31857DDC87AB523A1BB3365E07C6B5290B9F13
+ D77CA2D0F07C1DAF732EEEE77B668F452CE4062E179289FD50FCBE07A330DF79
+ 81D592198AFEE8C8B5897F4DE0CB81ACF1BA15449262E4C328A900C887F96B45
+ 409A5F4BFEA1F181E84B453848CE524E4C93225DDEB378963AF008DB52AA93FC
+ 7A5F2944558E0F5541121973DF61ADCE6128568E3066A27E916F5CC7D53C0F30
+ 92C1581ED74A4F85900B32D576789DDA3BA9F18B77112575E022A8C550772FC0
+ F4618BA71464ECE9CDD61CF80F3FA21A7475FED2C0388DA392E1902FBEE64711
+ 1F941CE93DB7673A00B2E2E8C4C919ADB51E017D342F36E222D9D448B20D8B2A
+ 77D7E30F9C8A141BA7979F08B55CD96CB71098E9E29BF7E3BE25CD5557DBF527
+ B31121074DAED3B553ED2C981146321E2F7B799792203D079EAB393AB76BEB39
+ F637BAFEA4B112B3B8BA85E7E5FF4FDCF1324244BF9F4DFC45E574CFF492D0D2
+ 021C91B3ED43D19087B982AE1C0658DB750B82664753FACB5FA2BD7BA6E0A818
+ 086FFBF0642E9A17DDB3332AA006C7DF11328CEEA0957424E4A68DBDD53B30A4
+ 9176930EEAFCA99F8EB42902DB226B9F9D1FDB1C0DA9F288FD7A9389F098DA23
+ C6953B57FEC7EC7B2C696D7ADA8463B3BBD88B08B30299FCACDAEBC8B5B4E6D1
+ 7CCC204D3CEE41CAA464D28C556DE63D765AEBC3012CF95FCD51DEDCCF78DCF4
+ F7E776203353AF7D29C92138BEC600D2528EA73E89948E826104780541EAFC52
+ 1E031158A7E3E97C63509262B358897FF919ED4D9931F1D2848D19166D9F6932
+ 5B4BDD00259E68C93AB2BE828904685DA53626C4E967CA5EE2434F0E7190BF28
+ 077D1F563468B50217F996A4DC7E63C41EB0B1825094ABD99FFCCDF3C3C21CBC
+ D0BC8F470F89AAFDF5AF82638943F7B767D7931BBD691384DB9DDFACA758CE6D
+ 8161C82B1FC862B2EFEEA70F636C3B071E364C72BD3987007746DE460487FD57
+ ABB5C8C9B273D9263CEFF5232EE91F7BB19F51069917A20238EF31A5EC4DCEC4
+ 7D9204411506D9DE9EAACA0DE973E1287F040D136CE8B24F571967FAA6A793F8
+ B30755E66E87023CE7B12069CF98AB1A0E48095C1F3678F862264BCEF6BE736B
+ D91C10912D09E570117AA75782724FF97D9F7976381FE5E5553BF06DBFF32CAD
+ CD8CC8FD8733A98C8F32C0172A704DBC70E7369DD39AF538327D8A8A54A7165B
+ D96CD2EC86BD04E1BFD3A1E79D0D55545EDD2315B80C3A3D406473B3354449F5
+ 41555B53250C7CC13A7B749B34CF86601D2A46FD1C83BE4C88C3DD86E6DDD855
+ A6A0F92E1B9BB4D6D4EEB2ABEEFC15516235006B229845B83949E56205879823
+ BE67506D1D8C4661D20AB7587CB3B2B4ACC8591B468B1F0EE89F00D2B7DF9D19
+ 0187E8FA7F677B699C69604DFA98FCCE951892476DC3B9E07CC565C7034CF20E
+ 0246F5DB19123C0FF6191AA1DF708A93638787CEEBF0A841D496A8C1305161A9
+ 32D3A0D0F90418347FF766B6349D86DA353B4A36F1B3432E8674443E9AE57AD7
+ 06A514CE91861BB92836DBAF34B8E6652D4F652C3820AED48C1E467C7FD768D5
+ FECDDB90505C2E47976524AB8948F1C4160E7AC31C2590A0B70EF4F6F28CE9F9
+ C7A30013BFD4CA7FF90263357AFD9C79EA5C707D59DC58DDADC75B12224F6CE1
+ 1AB21E7068BAE899B64139B60EF9A09774D93A49C26DC14149C77A5A71B09F48
+ 4AB3CC39DF34BF26BEAF165A7159E6B855C04C04349D058968E2E83F7FE9D130
+ D52F11118371A7BDD623E4B68F2CDA841C050094E194B4555694C2FD7240A331
+ 80C3AFAF14CA82B4533C87CD7B124406CE20EAA64D351AA60ED0326E1474C449
+ D4A6968C271CE710C558016E73B81C6B5E164D06A53FB65AEF72B5C3773BD3E7
+ 8C74BB6034E9ADB3A55E13BFEE64A62AB699FF148FDBF1E68372CC19F53E43EE
+ 57A1B39515EEA5703F64CE09399C007851D02F526963926794C7292C20DB071F
+ 0E9FBE66D344E83AFB4AE23DFAA20815D652BCE9467B03AD6A6993A7698EE3C8
+ 1BBD098CF4AF33BCD313E65671D33C76E7C42032BDDF49197D74A4F9A1DD8FC4
+ EB8A7B82ADFC9C584EDD2EE75BE3E0FEAD9546DE1B93154A94662FFF639BA76F
+ 6BC97C9B998108E79DF34832C7EBAB83DA810AD5F31FE266EFDD502F0565B6EC
+ 57ABB61A6F938730949FE95FFA1F6876CCD53D804D695D17B85F6A13472D789A
+ A709BF5A1460985E0DA8FFF55981791B45E4CF02B5606DE6E3BA88BB3539B63E
+ C3FA2788AD451A21B6B82F4AFA65F82C208358BF41C5D91EDB344BBA84F989FB
+ 87730B891CFD40760DA1FD3B9B8532DC046D43D5BE6489468D6652E1A394040E
+ F4F97F6B277CC0DBDFC77F2DC31D684BB491EB6CE6FD3BF0265E949CDEF59FFC
+ 71AD19D6E4579FBFAAE0C6D2867359D755D3AB8A76F41C11205868CECC4281A0
+ 3FCF14F1A546CA5064FF141CBD6D20AF4228F84655E13F10892599AD809E32B6
+ 2FDC20E345D17F22B514B89E645AA214EBD4F37F266DAC948E7505E30A49A869
+ DF11CEDD329960F733CB0C5E1D37730823DEA0B814EB36C09C827DE906EB11B1
+ A3176C60BA920C0B1E429778E32FA326CC392A2F512188D5D7A302C41F14775D
+ AC93334CC84327DB686C554D07F68FD79C3D7C87A94485C1C9048463FD2E255D
+ F7BA429687AA6432A60B4B2851675E8A6D7660692FC0BECA6E7C565A19D25080
+ 69C4F4E337C20521CCC4FD6A9A18E4720D39A78D3692867E846C43EA6E34DB77
+ 9410AB760F51FB5154C858549651B41B1AF41C8A5C5B8EF349DA0AF403CFBD98
+ 9414C39AF5FCCBCC24BA18726BC906F389999F0B9A677294D24FB49885E43E04
+ 2DE3EDC41708D3EB3DC88F59FCFC03F0723B495FFEEAA932AE3BAD0F9374917D
+ 5848C3C990E8B77866669068ADC7B7C20FB1F44FE3F73D3234B470773079DCBE
+ F29ECF3518BF1E95A785FF6A14A6C9E6EE6ECC1BCBE07C7003BF98BF43FA2728
+ A17CB104D420B2D2EE35D6A7492C9903E46535A4673D49DC59D304869A34E922
+ A5384CB646CA71DA659BD9AC068B08FDD65EC2DEA4791757BB73845C8E93C45D
+ 2741CF3300AC21468A9C4E8078C5D5E9171BFB9ACD734F6422AD8D2461C5C159
+ 56BF1CB2C68422031DCE68234E1BBE63FBC6E78179A3468338D3ED2CE831AD48
+ C5FD35888D30ADC025BC5D740D4CD580B3D3A92570F68CE5AC8E9E20D7F9C4DC
+ 4D185877D61D217BD058B835FE25F3C8CC6BC0DD619F9857EC2F9131C6DEB9B2
+ 893301002AC443599C2BCE35A25C50F3C446F1E703F3693BC1D5EF2D6D6D3178
+ A1448F55924CCABC05D458E47ADAD89D14554F92085AC355B26440E7F8CA2263
+ DDA3369902281BC3C19607C519A09C5FB1EFF478E1870DC278FF4498AA1E8BB7
+ 12A23693AB8639CB5B7893BBDCB84D9B88384A27CBAC524DC9115B7848322662
+ 3D22F3AFC7D1A1CBD5D6C73B1CB6273C816FC68990B2A7ECF4EF910974123F9B
+ E09211A76A8A5DF469BA835EADB3B06BEC6AC901755A96925121820D2FC6B4E4
+ 668F0EF5110788FD5B504ABF7B5DE2B9CD641484D46A024B0B8D0E57D007C385
+ 71D3C280A832D5B271F5C53DDC36A6C33EA5F4B1D4169C92FCC4A238D7B09217
+ 25E2795FE5B2C3E0E0AAF71804FADB2C95831B5B199BE5B466B736878C72409F
+ 7F386E0E6E433C2D2D167CB3F9B2393B25BD10870AC42D275E63100B00FA5854
+ 74632128B7EE00D10B854BAAF8A0EBC30B2F9806A76810CDF039DD5D35B1C069
+ BD5AE7A86A361F44648D549DCD88F3E10DAE649AD0BB5B3565187C6D106C7A07
+ 89D47157CF9E5A45DE3002CE17E8A1A7FAE6C51A541911846AABDE9B56C51777
+ 8EEAC2F3104E46CE8318BF47AD428F1A43C5D890356467F26D8863CF5A4030D7
+ 40B2C36A8C5825BF8612C6A560557875309E684C0CF2190ACD40AAFBB6F98910
+ 1D35131FE791F03394CAEC3045E8AF3FCEFA529C6042D008CE3B5FA02F58F42D
+ 9DFC9B912A435C683280D4815150CFD2609099E07E1087733863E4E89F6A3134
+ 6731402B885344BA762DABDF545EDAC16BDF01AD5340345C6F60194425C09781
+ AAA21E4F62A50DF83AFE3AC0F93D7A13048E15488E9AB7A8EA41A51BD212BF4E
+ 75D99A00AA2F4293AFD36CADD0B73F71DAB95376275F0FC27B935359B5C01A1F
+ 5270AA88D1C982D764C88D93D3847E22918C40E0215DB96D520F6D79EC5A6C12
+ 70180E065E34D100E62C82FE9D650380E0B3220384842F03E19B3F8860AD96DF
+ 4D7D84B298564390FA05A4FD3F2A49962590766A3DA30008A8A46664A807D1D6
+ 60E040F76A45429EEC34D3CD0BD30C3D1AFF8A1E6D6C826E4B50F0E3CB34990B
+ EC95E8D4ADB241C17468ED53C04FFF1D02A919C5E3349729AD289CED42646EFE
+ 727582FE6FCB4059E9A3438AAD8056B2408E4BC75FE890476991752F0AEF9352
+ 681BEBFAA925104FB814EFF51AB074F80EBF507373D0FCB1185CA04B7ECCAE28
+ FBB5B1A90B5EC87876DB4278F463382245062231708DCE571BAF681A346A2B28
+ 479B63E2831401B11065C94B873884F85ED4217EEB434553EF8500145F4C777D
+ 9F56056D1C8FF590AFDFA2C439B23AAB649F61758013A5390C8189BB2E3F4D1F
+ 0AEF1F755A1F622F5902CA9DC89C42AF41B0503EE56E42162727867180F5BB01
+ 5435253F38D1D0AD3EF2A84F4F16238FAE52CB11FB5A2A2D78503F42212FB88C
+ 4B41F68D3C3D07FF0C3557B96CB897BFD307043C45C13D772A35B4C4543170EB
+ 74E88217BC7415201078D6D7A69D518E06BA8AEE275030337AFECFFAF4AFD885
+ 3A0B0B7A809810ED609698F2A50C66296770E607A739C467F8E236EB24A39369
+ 6CF17A84343CAEED14F8088A751EAE1047D6807E6268ADADF04EC2FA41935988
+ 302A8D1759C3591D50A43156BA792155DFDADEB64D834AECAD744CA40530FF35
+ 9FD272756A676F9BCF417ED1D3DE0EA5DF9187A5469E69E880966B9F32CFBF59
+ A063C93AE0720C67668B17231D74AC5D5842CF86CB1745F224DA0F7D9F55AB5F
+ A3E4378517402171F1414E085F97716ADA83E0FD0CDBF502DE286D2F4DF3B670
+ 4AE6B942DFB4EE55A7FA90F6266BCB4E412FB6B3D973C6DE0D2BBB7E0CB0E782
+ AA51D84EC5475C9A0B6390A9ECEBFD96F1B3DA6226562DFF10FE8641F4916AE5
+ 7E2EAC73621C03B3F739E5CF8EEC79753D9B677C206E0DA098FCF8C5BD0D01DF
+ 978D067E5CC15E9E63C97528CF518848B1F0AF43786CCD3538C20129B9AB6937
+ 56CDB5D21E472EF6641FFBEA9F5D6653921F32AF69572E9FCAF4558448B57068
+ A885AE395CF08E78145AB9AA0FB1CA1F186F0AB715B59D5B0791225A53FFAF1C
+ 3C5FE085A09918517C967F63CA8AA591DE2AC242539738E10041FB579249EF1D
+ 69A623B2D8EEB51FE828F03680AD890D50DBB2334BE140865865B63AC4F1417E
+ 4825C690D5C50F10696B3A314E704C56963D3F78A1A2BE72E1DFCA466843D6C2
+ 1D4D064D4912987785522659F71E7369522CDF0F2015211B3E5B2F1B17FD7278
+ 7FD69B82063929A65012A208D94A0874B9CFF274D2EB8D43F0FE1C9983E49F79
+ 0BBFE53EECF64395D7667BD2A5564AA1571B33F91EB72ADA4FA876D2E671DC77
+ 5EF232EBC0213CB168E6417596715D13413F641D7896AC29156AF6632128275E
+ FD63C8983E4B80FD3463CDA5E79B3718365972A057C88BA335D13BE19A45D584
+ AA8FDBA2148D8F3B2C249E702852A43502BBBB10938CEFD550DFB8D0F9763177
+ 650457C2265092AC3ABAFDFC93D9FA46847743C81A7976A1FE6B17D1E4D497BB
+ 141619A187C6A56E2BA86899395B7B6001BB495451DB92FD0239D925C44B84FE
+ 666E2203032C51D4839E271E3E500FF3ECAB8DB9E245A691E852110322A1E026
+ FEF39BC8DDE46A803662F41F38A14C6B7B75D21E18CFBFDF621C1DF63E4D58BF
+ C542E54F28B5AF2DFC7CC00294CD24D5F12EA06F1259A882ECF2C32E1B679516
+ 9D4CA1D5303971FCC0951FE0F1651CF28FC9F92CCB3703B524034482DB2934DE
+ D92F5C66C48F9A0EEA490AA4E5328B7067D661D4C0F3284593D62AF061244C97
+ 8C641E6BCB93BEEF4F1A93F6FCD757BE1CA5D2EF11D21CE56D2910FB3CDDC8DE
+ 89BAB3BB18F7634A1A802327090A538A4282F91AC46D6F4C15260F76FAC45598
+ 65E5AA5D5E0538EC7E091B104B563405AF3224AD2E60698B42923631EB748FD9
+ 24A26FD965A55BC6D0C490D3A901C87AF81E133EB92B134F38C24AD299020281
+ C32BB1FDED001101D25DA65A076E0AA4F33CFCCD46A34F131302ACD2723DB769
+ 646A62BC17EF1413E588FDC8BCF7DF3ACCA888BCC1A34980F4810293CB7D0354
+ CBE4599094DD28CE57D805DF8BCB7BBE8687A3EB39EEC505BA1478D377AFE22F
+ 2B973CBE790F858F0FDCE745871E92246A7680B594DDE5FBB7B9259029AC29AB
+ F4239D50FED5237922903701DE63675867638AD233B1DFE47AC2D6D709F04ED4
+ 97BC682FDD864F41F56BF8001406A9F62FE06A15DD6AB807D7FE52733E00A792
+ 39DFAE7E684FE46E5AAD2D7E178AEA651453F7C585A065DD8052E0D5EE84E651
+ 75A09A313CA3F521C57DEF18861B5DF88EF9DCFBD0B84F5389BC3572A4065541
+ 00608C9E3473057C8998C9D890C3CA79F756B161BAE9F75D3727B703E4AC39BC
+ 127D4E381C86CA92DD831FCC76A3B78B6A460D13042B171391FA0E5564CCADDA
+ A4CA6EA9CC5D6FA432A7CDD0559B6CEAF24740CC84577EFD6AA0A56452ABE5F4
+ 73E01DADEEAADD4A5A346E3CF2E5066B24328699448519231DAFCCEFCBDB5495
+ 3FA5A11060E1709A4496FAD1E89D97146CF3F6A0C05C577A2E265338FD9FD0C0
+ 3883B7F8613889FE6D5262AB02EF81478CB315E42B77BC2650330597A69EA935
+ 236E40981B6C7D8AEFC24B9E51900F6550B196514D69C4B74BA842EE8C332614
+ 8D4EF8C9244C593FFA6FB4C196D1B3F805032D0831E6BC493C86D2A66D672476
+ B4F8434CD2CD023558BC2A540CF132FEF29025D7A1B7699DFA4AB63A614A79DA
+ EA2FC825A35B61E0A42B51DFF5E0BD751FEDEEA5BB1CBD0913639C69CDA2C8FC
+ 5A5BD142C5664D751CA83542C72E876EED4AD8678537968FDADE56999BCDE583
+ D80A680A57A151F174B317DE5C5936955BBD1387628F95E98A2CAA217272A955
+ 518D79267B0315B803B3814F874964F42C7452E24924736AD68CE3845B0752F3
+ E9F0832AC3A6932B2BA246AFC091201D7A19DD76075F5CE36384B3712EB1D7C8
+ B8DC9C867E2A68BC3B773BBE030B4E466C9BA967E45B92D53496FAAD421ECD22
+ DEBC309695C61D66CC98BD5330D8A95DC3C60CE861A2B444DE7432FD763B9D8C
+ CB53D83F40851A8D4583FBAA1AC314CC9F08B3D891B0E63EC06737061BF05F5D
+ 5AB58585F4015B747AED2CF2FB55D5056DDDAF27381F29892E328909731234B6
+ 1BC6876162051D1FD0F3AFF77DDB3C8DB589FAC5A9B43A1CDF58028F01F19CA3
+ 41E3F8ED7107051663809E466C892BFD51DBBE02D18759E6793864FC068E199E
+ C1B91DD92AEB4ABCE0A0CDA11E9B2600B6373833E8B97EBD998618935E4804BE
+ FEB1025431F2A761B541004CA25E9A1172A5F0EE3E765246F593149B320C3E0A
+ FE96F2861929D927C14CA7A6E8DF7BE57D17BEE8D90D5AA639FD57B694457698
+ 9505E1C280B5E2CEA443E93B6B69F41FC2D560B6B3DEC0890B3D2FC5A2D32BA0
+ 3C4E1C7ED4353763B97C6F04C070643FE9C91755E5237D26E0D4EA46EF9F2CC1
+ D0D43A97A837B9462749B3F6AC297A0D387B5BD5C124DB3E4DF57B9531CC6946
+ AAF10F35B9036BC2C1E4E3ADF8783D2060DB207A8353E5002400976A36448F59
+ 792780C6EB65F6C642A22C0512FF273DC6FBAF743CCD8E924C14451E5DB60CFA
+ 5D2B125989D29229BCCBC25B89D497BCB611257EA358D40697E66CC36AC194AF
+ 60B26C16599986E0788246941D3E3006701F6B7AADC272203378201A855CDACA
+ EE86576FE1B0DA01C34573FA06A62359934354900C79A53BC43AA8EF8F075A54
+ 91B0D6653F617B2390585B88F71447B9B87A40A0E9A90BEFAB9A676EAC6F1FF0
+ 89B771804D714902E1203BCA0FDEE7857C05F502C4441DBB0CA9EA4ED6E9FF7C
+ FD407C178625EF9BB68338276B0BA383BB970F808B6EFFB1D8D68828105803EE
+ AF215EF8657C6567B89F9977E0B1B6B5A311D246780729E0DB16609C032C02D4
+ 28F6C4116D714C0D047F816A3B1DB5BA3015E0C9EB38CD32AC7A6AB53E7CA1CA
+ D8D91686EF1C7E53EFABC4FA118409FAFE0E6CB3AEAB24074C2CF31A2E9D6C97
+ 9DD0CA7E3D7DF5A59CF464E19F02ECC457C7521FC5936AFAA9BA7D01890E8CCB
+ 81889AC0F02C90697F3362AFBE5791369E1B374112E0815899C3B9F1B06F326A
+ 218EBE325333F8D564AA88072E281D0C675733841AEEB7EB7A2B02D07FF7C233
+ DABA1A225288801E4CADBD9998B999C1983440CE8008B613B94FB4789262B14E
+ C15920BA2EF907EC970111953BB3756CBB72899CF56AF67638BB932446DA228D
+ 43E136F5D2B8B2145508B65C1F78D190B168546669C30AB1A1F6B8F06305A7F2
+ 0DE39D2B147A1B5918701B4850EC6C9CD9BEB86C5AC8F359A4B866AFF5BDC717
+ A3776EDEEB7FE5437425EFCF60C968F9EB65BE41D6CB5FA8768178D3EC94ED61
+ FA5AD66ECA01027044E292EBEC384D6FB64C67F6BF7A164E82F5A75BBDAEDD54
+ 11616AAF027B7DD6D9639317F2D59AE8E3C0E2005BDE0A79DF12A0283386611E
+ EDEDF8F31944A567303381FD5A34F1D5F49B793681E56BD833CFC98A08EAC312
+ 0A6306ACFFE87BAFBABCFEA46899F4AFFE10D226675A4BF7D93AED7BD63876BC
+ 69AF8381595756FDA9D15E9B625A1FFB56164CDE2C97FFA47B1462897E2420DB
+ 1262B172CBB317C2A870F453005DB58F5CFCBC2B4FA325B09ED2B066BA4A1731
+ 86C07654AFC48DA0B86AEDBD41A8CE357F52FF145C4D55D6CABE67AA7788B6F0
+ ABDBAC3F2936083B690AD8D921131D0F72C223554B38E3E20824C48F6D3EEBD6
+ 49D20EA3D8EEDB03C45EA06325D2EB245670DE26E5F1C6B4B2D8AA8578793AA6
+ 0C6EA4ADBF719A34D5EB8237EAB92A22223FD62EC37654170D2EBB5AE2DF50DA
+ A0570D531D0FA6ABAEF20F0D553F2E8975289056918E2937D29D356200C9C273
+ 554E1DBA61515D0A04B7C9C80972F42B920B0001139D91741BFE1B561874C9EC
+ 97D70350F1F2AD346C9ACFC87B1D12AC731001EC0BA76DCE4444185E6D62CE90
+ 4454EB5826E1D1C4B97BE2475986E75837FD8ACD3BD25DD790B5937E2D5709EC
+ CD31475401DBE9A8C9E3C90C2BDAE36C3D383587CA431A9020335E5C20929256
+ E4139ECB0EF66730662407B3D1928E9C0C0EEB1F3359107144654763483C20B3
+ 772DD0EDC941D5F58331EBC564B172E1DD780FA15B1069DE2FD40AE89DC50E47
+ 0CC9A551A1A25B53BD14E3060B3AADD17E7EC51CDEE593CFCC452B4212F96ED7
+ 4235C239C08BCDB41A17D82B6818B42674639FC16EC411B0EE35551C0D440A75
+ 0AB29CE4EBC3087E8B388EE9CEEB267D9CA6F712904C2BA7CAD06E7CA382825D
+ 775A9935E7B7263E628A71F8700F0CFB7DDBEF16E6D79A056F86FDBAEDA52C4D
+ D253D3C7C8AC2FBF80162B1AA540E1B98103D8DAF91F4A66036EADCF9378D0DE
+ FD0736D2BA1B927835D016174E50750CBB6E09DBA8C59396DD076084957815AC
+ E19EC49F2534A71A77E092C0F4334280783BAB08F93AEDA960A1FC8C038D6458
+ FFA03ED66CB775802F4FB356DB160445C013892E0849035778B22499BA4C2001
+ 89F6AACAB787FA071CF6ABA27821900CA88A70B344C8FE6BC4106024F40835D8
+ 0BAAF348F362346DABFE3C840B93BBBE04B2257AAB2398A41EA399C10CCD45A3
+ 8689CAACB383754E93AEB8CD8A59449887D7A65C609CA3FEC70BA9B97BC11C19
+ 3AEC5AA8775E8BA634FFF6DA7F5A468E7CCBB19AFBF9538115D138087544DD05
+ E83FD04DC50C61E954CA44464BC8ADB19B8D092BA80F8065B9081F276CF0B2D1
+ 5771C1F99B355FB04401516546EE9071725B1EF7149952A47053AD40E36C023C
+ 4C8E8EA6CD80FF2BB23C30C60DC71BACC014A3DD24EF86B0B158915C95273C94
+ 6F933F236A60AFA21A486577ACAFB0665D1CF4049EFF2189EB3496340FC71AB4
+ 7C5B8ED45271F2AD2302DA402F8261AEF571A86066EAEA24567F93A67109294E
+ 973E8AF1E33167DDEBD79A6C43B1381509FAB5169FFE9B9BE8194635CB5980AF
+ 9754B1EA56180B9B67EC7742955A4A1EA6637D46B0EB43B5CA7A54911D79E2FA
+ DF9AC7DD6D0E8EB66A9ED2BDC199D95BE581AA36555DA2A5C2F0518529BCA4D5
+ 5BFC3E6316044FF55897F1EAAB59E2BA492B90A2ADA7B62EE88B6964FF6E1557
+ BF8D0BA0A3A464597646B32B4F0C51672515D309C8FA9EC6E3B0ADEF2E7A6046
+ 6DBCE69AE7FC23F802F6DB200C5015D308136465804C28B38EAE4DFD0EF5C745
+ A6831E2AB04C2763E49436E23DC980F8CFB8B403D26FEBD249F551CD76D13645
+ 2A59C25A4B25E4CDE421828BB8C96A77EEF56A70DE3E7B6BAA4F00905D345188
+ 5D0ABC7FBC4F27C67DEF29BC237AED6CFD8DF08FD3A5F45447224B9B25B16852
+ A8114336FA3CF0DF66A3B8ABAA6B75517C582D5608F50898DB9D41832E49DD50
+ 4950337B07CEA14C06C3034F16E3EA8360399C74BE40E172E8C1CB25E14496BC
+ 3CA607FC5F7EE3C77EBCF2FA424998A53FE73D8FFB90259DF706142E05B8F185
+ E4F4A783AA1B6BCB04C9EDE7977438BD78F1BF63947999CDDB8268D4FDFE96F0
+ 4D9687CC919B5C7A7C9E964D12A9EC42099EA839A0313962FFBF796AB168538F
+ F27A622122B228931452EB8AA4AEB99D1F5665EB67284CB39DA572C031246740
+ 65F2557F3B3A407634FB16FC54832BEBA6A9456DD43940A3CAE8C627B25F386C
+ 1C438666852A5108D7A03195FF09DADE61B5E415C20892293A68FEA5AA510F7D
+ 8846D78283E2CA86E44F4A496DD5BBD3EDEB78559E4E6DCA096F5AB7DD8EB460
+ CE79E3639312B96F1B2A85054001584A95A74953247495D72312A77077CD2C53
+ 69692849FD94EC512FAB127AB5D0404CDFC7D1BA581C27812A1841C659D73170
+ EC523C29E80D82FEBE2F6C8C3C4312B7C0DA073F2CD472B626220509052ED14C
+ 9FFBBD0A5E500DB024A0D7CC6188FA23F555AC8BEC1BD4D2BEA69157E9220BA1
+ 47803CF44B7965C340C31DBCBA4DFA506B7ED096E5E6AC1C82ED8B75D7BE9AE2
+ F04521ECA7D6F127160097CFA06766500DD4AD7FEC0E2A6915D525CFCE439425
+ 1E8C104FFDE5CAE394F80D8934AACB6925AB76F0849F1D578358F78810DE1B02
+ 9A62E208A2727D5D56A4004C267B6753E9BB1A5DEA2B4DA0F097957E740169E8
+ A95E65D63329B0CDCDF8A7DB27A0C4CF9BC6416C370999B2405994172A9AD1A7
+ FAD4428792E29E9269A118DE8F88DAF266268DE08A4ACD053F2F7DA89BAB737E
+ 866DF66608152DE7AE798594E218126F3D53A5A4CDA941F8F58652E69143512B
+ 46E46B110F7D679E3A385BB51C53AD8C23478CA045F03850DE3130A8C6A67237
+ 005A17D16398AECD3CACF0FD3DAD569C8F4C4BBEAA62DD4C0134BFF1C6F1C79B
+ C68C49F2DC2429C3F3CCFD86A80F778B179B5358943BE6C83D04000A3B32E092
+ A5E732E7054149B241C71542ECDE40B8253CF61A0EC91191181C11CB1CD7218D
+ 2D3A25B01A3EB0285B88B980E8723202F994E2A9EDBAF55F39B822A6719B8DAB
+ 7A86F4DCC5AC19FEEE69D5D4D9E3AB5E0D6484F59621577655323A8268B6A664
+ 3E1D03EF87350F96A8B20FA89112BB88D32CB894A6073493B705285BBDCA5A59
+ DB09DA6377C4D66BFBCBA1D5714E004832537F1AF8BB654FA59EDE990D3EDAFF
+ C37078226C0DABD7306E8CF89F415DD2DB715FD90987E3B9B9181B78E644F691
+ 256330E53895E8F0D53C8D332413D45CA270CEE2366575664DB44DF2719CC4A5
+ 38F999638924CE5A17CFE73AD2A20FBB8126CBD644663EDA6970EEA2B09BB669
+ 1049A57B3364C236BC3AD2F75A79718A85B297B9D64E2AD16DEA81DA44B97F1C
+ FFF05376DABA294BE3FF560AE2E147B61BF68ED3EACF3D4D9E64446BE6895BA5
+ F7D57C0CE9657C655E8D27A07C1A6C06FAC33A4C62240A1DFA7A581D72F470C8
+ 8F6A95A9F53C1363F0060FC8630FACF4631C8794524626B7BF791990783E38ED
+ 7C91AF835B6206669C2D53B43AB850EC8CA67ECC722B7DC998567B15293A5671
+ FAD97D2397BB1E6DF8BDE386A93C885DA6FE4277A4C15B6B5CF3DD5CA9C5F75E
+ B55A75469A2FF8F6EB91778758281621651EE7658DC3EEC042FDE2B1EF83AC8D
+ 49A7F0319639E85911A6249E4C6C60330BCD27160D4F884ECE3D7D2EB62F8B17
+ C53616B5C56E1B3A955B057D4C9F0CB982ABF6B3C71FB960F84A3D2E43A9AC79
+ 74DF73E2A960964955F56311C7B1E9910A8518258CA59AAAD6B36425471EBBA9
+ 59A01533D1B71A5D65749CF73BA2DF5826755DEF046594A9D830DDD8FE2ADDF1
+ 10DAC4F0C4224E1D65E496016A615C52D743BD23CE241AF08236A4C9EAB879AB
+ FFCD8700128DD28DA59C94420EED95E8CE1E7BF3E50ADA51BDC6D402309EFCAA
+ 3DE5288857DD6F2581165A265DE712ECB14C88072A174972646511AF410417CE
+ 7E5152AC242072391CFFF68E909B0C234B965BFDFBE9A44176F2254DA7B94C12
+ BBFBB00BDFE22C1467B20B003E4278E77FF4FF21E78987D25C9BECDB7CC3EB16
+ 0AFC13A5C6A05D7E11B778FD0591865F637B2B63ED151FE61B317EEA81799314
+ 5CE3E4D9ED1F1C1857DD615AE4EBA12BF4B482396030382BC06BCAE522257285
+ 14F489DB7BA7EC66FB19AB11A9FA00BC3E364C395190F940698C8FC7E6106F00
+ BC843E6948175323AFB4E61ACBDFF86AE91DF51C523BB52071C645B04FA6C95F
+ B9179EA1E6F36115BA291BAA5FB593E8DE8DA27230CE51461969F6321A9B327B
+ E7AA030CE775B7A3D9D1D69C2D769BE73AB840CB2BF58727F576F701AB2B7DFE
+ EFC2E7162EAED74E96DA841115E950E561F23CCCC37455E641F40158EE7CD518
+ 7B50333EA5F3D80AC357CBEA44DF35BDB90A7CD6F9F78F7BF9146E99A2CB3AD7
+ 8B8A62D95A8F44996F93B081F733FBA05E15DB056F8112D15430EFF4C78F9334
+ 005C32BD02E9620E062D16A45004D0DFC9135412E68DF0BD2921471747876B97
+ 75708EE9C5FD0578C49D205FEDE75F4E4FD5C35CFF78D7985DBDED5E65927CD9
+ FC519AEF57209D50F584601A7AB248540E8FD31160DE5BD57C7F4DB8C18D244A
+ FFB69B72E7AC8C1CB416838A16719CF6018028532C4E21AFA9ED63B4DEEB1B90
+ 878437271DB586D7B5BA06D882D168A01CAFBC87C2080BDCA23377E711422C9A
+ B1198687D1E78796D410C1681BEE836EE6E6221EB95180133BE78C170B862C56
+ B21EA2081E5639700EC90DA78D66822D9E336F6A41086C8700381C1C1B4DA3A1
+ 7995869C5D85AE7FBCA845E859BA7E863641BBDA1418CACCFBD463DE3EC452F6
+ D66B2F8FB976E464FA378A8D514CBA74A5DE983618A62B0A4B12847A65FC59D1
+ 7A6009365B9318475F74B23ED3B5C2F42C753473058433B7F2FF9ED01E61FE2F
+ C8D0B2017152436394CE59983215D0F60A42F06C60C6760BC04D63FA91A4C5A4
+ 4CFD19F11D0679DD8017523E30E1D01E2BECBBDCD2B8CF595733640EF278A73B
+ B1993DA12CFE296CA2EAC6AAF47D81F60DBAD0D956FBA5DEA44969A02BEF04C2
+ 21C2AD37EC239317227CA1E51F03BB430498CDB6D5945E30C388589883B78ED4
+ 943EEF85D7D03713146915D5410702AE57D34AF6F082B54D691338A73B22CA56
+ A472AC4496ADCE51DFEFFF5FA86876F2510D406EA2405A74B2EF3C551ADC2191
+ 385F867797F7BA235B1E133531D26ACF6ABF4E222BF93577BED83D19C1D55C47
+ 4F64D3910000F6FAA20F502CFD90534894A26990FAEFE1014AD50D8C8BF96217
+ D73136480BAB67BA1E4BECE8F20D58227639E1A0D5B99DF961210CAE231BB4A9
+ 4BEA69F82A215876B806E8BF9C2846B7701C830CA697B3DF4B141E9F5D4239F1
+ BF11D8EA5DC77A21C5A716AD8F6BA877FE9489CE2B92D311EDC92C7AE6099048
+ 2DFD25E083DCBD555338300605C568BBFE7BB14C14587E2B18EC290B936C0158
+ 63330E19ACB55B3C7313450C204B7614E301F0FEAEAA010743FD57B99877E5C9
+ CD99EA4B4A9CB138DFA39C338F5D80A9020086E1E318EF7A940130789EFD7141
+ 7A8C67C4591FDF59BAF2C30A4CED19BABE5EF4C753349BC20FAE84F0575E811A
+ E1A17D43EF57867BFDE2801ACC84B54BD39F3AE1CF22AEF029E0C1FF743834ED
+ 8B67A99CD0ABE760364745F5ECFB274F1496C8A8AC820CF60710E8173C3CBC3E
+ E36ACAC8A4F1C9FA8F32955911938DAC1645C88D4D1D0410036032387C9C57DF
+ E75E768534F5F55A021E4A420081D666527BBFF8ED46C05C57489C7099A80428
+ 34E8797C6F869E7DB20D290702B7B64CC5AF8CA23AEBA39B3727FC330D44241B
+ 1435E36E914F0075A276E1149C37129210D0E6A465FAAFCB993A0B01661DC183
+ 083865EE42D086FB76E70E2102815C51CF64109F2AD04D5D3E922B2DBAC58938
+ 52063A68FD6D7439972B973058316FE5AF8B21D1AE5ADEA6904C8C20543A7652
+ 14BFB2E19EDF0378B88C3CCEBB76B06EC3177ADC46840BF3E33C44B6F204247B
+ 8CBDE88CF1D67CD117BA5F26A3A03F7E6189EC11327016648CD2EE9951719F8A
+ F068056AAAD112541075D7B344AF8443A8D5E3EB358E13DCF3E9BF297FDB1829
+ 1821B48609C1A59AC09332D51BD18365D996728A7630151A70CD076657FEFEC6
+ 1F802414F773FD67FAEB60F19783C10BA98DA798F8B27A460D106AAF3F280442
+ 90DAF0AFE5EB5CE2CE0406C76267D90A9BC3134D02673984ECC86F877D4B0F6A
+ 8169A33B2B121F08BDBE40CC0778FF7E6F750F25DE3596B3E6BFD685208F88F6
+ 4F09FAE3CCE2BE7363EF85A620294C9E90644FF4BABBF992A7AFF5A4A2723FD1
+ 0FFC2BD04D08945629CD25ACB3AE85883297EB0D578DC6D4012A72F7D850CFFC
+ 75A61F0BBF8AB9150623821D7D8C8204919D0816BB7F1A90A26912BB14190D3A
+ 93AE973CB3D8E2CA4A8BC1D6A8BFE11FE5ED718F58BDD7568D9FD3FBCBF18081
+ D2551BE6E04637E42F3D2A3DD3D8F8CB5C634F0FF00B2EE3181BBFA59726E8AB
+ BC20CA47434125832774463521C46A06BCDAFDA45C60E2FFD6B304CEF59D62A5
+ 51FDDE67504F05B18B269FAB5D738574AAE56874B572D7AD1B6477B889A03C7A
+ 37F20B8479EA3B8B4617ABCFD44BB877C804E25C8D16A80DECE7D9B13546E434
+ 56FF86AFC7CEEE490B365D175AA056A4C3905AE6554F129F97FB6422E8128D86
+ 434EC57D768105DE9938B2E31272F06CC86DD8DD0890AB7414A8E561821DA3EB
+ E64A6454513384BA19C410AAB8D25D96FA4C336FBB19CBEF127F1466AB6BB03C
+ 52B55864419B670C4362477E37D17DEED3A54A4F407DDD9C7E4A25D0492C5455
+ 16352AB87131F1C277452B25A7631CB85E087B91D9C883301C6AD3D4864B1930
+ 173F2A989A348A63FE43E1354A0CF32E83DE718783126BB0C26F8DB84448F45E
+ 3A9A59DC045A5DCCBBC81F60AFD7105A52D5CD416B11A8E083801924EAB2E8BA
+ 4A7D7D1E58378BA2E87629C7F71785B5724EBD50586A5482F209B1DCC3850423
+ BC447CC9D8C379F74210F161FEE4DB124C6A59648866DEA9765D96928E567DA7
+ ED99795B12B4F228FAAB1EDE92C667A71DE86F384EAEF688A4F18F0D148D3FB8
+ 9D05476DD37EDA971BD4A933A8A2245601984818FD9C0B5B7995C3509F426301
+ D61E858050B96522F5BCAE3D337510CF1274429193A9D6758832B990232229DE
+ 5500E6194B538122885B068FF9EB77DCEAF45F91E9F37A59431521D9601FB916
+ EDA7AE657B77DDCF8C815786BFB30D9B83F87FE002D1A1ADA1D49609671BB895
+ 5AA5E4975386F2B3E853875A1847D5598D1C74A339E9B5083A4165E6FEFD4A26
+ 344A8692A793A010CCEA63429F71B88ECE4C8073F7B11B70ACC73E83AB46EDE8
+ 4B187A037FD1D551E2619931AD653DA6DBE0933CE1051CE5657E251B67C2320D
+ 5BF3E55475BAD2C9B76092FA9D42663F3F87699709933447BD72AE49EA517311
+ 2DE4C46EF7A0CBE2CB4FD6E5EDB73DE88CD37881E85D4BD7CFFCCD99585A9868
+ B5E484FEB32849055549FFB3AE641B2F7A0F0F8441BC0AEBDCDD900D692C94BD
+ 0FA71714D9461B95C96F5A3B643328D8CB4C9A009A2DB0CF7E25E00F0EDC74C1
+ C67EFD4D85476BE96882ADFF4471B8B83AB857913A706CF4E85764B8CD1E3652
+ 0F8705DC07FB7F1E0BC67F539A6F3D70EB705926522BD916446F8D6B907B6A64
+ 047A7BD9AE24B9A2760CB86D3A738D152CBFCB6CD715D5DFAB6553916BA6E88C
+ F04D816EABAD435DD9E3FEB10607D1613C4E1ECE85F4BD57D3DCC7DDBF1012CC
+ C211B2E1486AC95A2C73E6D39DF327606AECB5D57C228176CA2399CBA59E5F93
+ 38999628F730011631DBD1D7FEBA2C606C5D090830A840B2C61EB67B14F4892E
+ 5200262AFC20F4FA0430402833A1526C5BC3BF644CC306417FB4454FFA679B68
+ 0D102693010CEE93052ED2448BE445C53039BFE6B3157FB374064B949519AD45
+ 4E9899D31F3C9FE2B700A312BA14B1E986F19D65657C649C59F73170A07826B8
+ 8120F5C085AF00B7F011844D25ED7E947CE566D801EB4337A5C8936325BAAD61
+ 2981D5EC2167FA36B304EF931BA81C7142FC8F7D19F4B05CEC1560A29D30237A
+ F11FC5CD3DD2C78FC6B5CF064A4B0B4F4A6CC756AB1EB6C69FC731D0ED7267B4
+ D04717B70EABEB5FA80A5FA3400F497E764B954A533FF4DAB733A29E419D8CD8
+ D8C41401DD450CD1833CA72C97701269AADCE02BA743B4F355B5D99638493F4B
+ 946FD3C2D3001E446373685DF80C6D43686FB09BBCD1D5FF956455F62E9665D7
+ 25E4918B881D7157AFAB614F3E52E2A1359401B663D43693749424DA8308C86F
+ 5B09EF581D137892921EA53FA87382E482BD3EEA2A87BAB21CABD3B36218AE2D
+ E0B210A5FCD16A3715FB23EBB742AD451D869F91769D10E3CDFA260967B008D8
+ 7FD8ADB45266B70B75BDEB57CC2446FEB75B13B665FE0AD32A6CC01074BDCDC5
+ 6132D5BF969A17A2A86F15DAC7AB93304EF02AF59D6926D1BB5B5BD975F5076E
+ 510DFE19425F259A858F03AB4BDCBAA8E20C8BC7AF22AEBB369FA70FFF23B0A9
+ 4883033CC04581B613A634A6348E83CC27FE5B4917FAB604B417A9B8E5751B90
+ 5C75DA865449B0B83C7E8BBAE83B78D1B350D0B06BDFC1E403E62CADE6BEE633
+ F6F0B686851301B810505550CEDBA3386C20F8E6D4283FA990E6144560BAE063
+ 4073CD0B6EE1A2C9CBA81C0ED110590D1C7DC18EF7A9DA3A1BE168FDCE05CBAA
+ 2C641F2F9036F0F696736673EA1370BE676612722A776F522690186B3C08613C
+ 030AD8D464771D4602BC6A0B14FB5BE8DF098E8497CEAA9AE52CFE26CDD1766B
+ 4A33539E4C1D3BC953DC693AB4CAFC09921F1CBD681B57DA1CF3FC97BA3E6C31
+ 411ECD5938BA3080E5F7CB185F2839FACA4D265C67244CBD47E505340AC4822C
+ 72A7C975EC6C8FB4677F33D263372E3F19D14498FAFCD38DE6E7D4BE0A447548
+ C5BDAE24F436846278AB79C687901C3C6978A522933579A3D9C4E1E85F5FB362
+ 05AD0A3F603FF0F41C70AB4E2C6CBD4C0121581CDA4A3C3C1C54AD23625EEC8F
+ 98FB11D5880D2E79F48401F60D64F7280203EDAA1661BEF85EB288A58A2F146A
+ B993A0F1A481815FB2D755D5F6E0E33858982DFF3716FAC4A4459159648CEEAD
+ 35B6BA6E87F6E7ED7363D30EF1EB2E4BE52B613E2FC662E17C4961866BEB0CB8
+ CF5747EE84373CBF3FEA84B960E97511D0B75D35017737C3B33F6802E5391F36
+ 4F88A9360AC334718FA9BD764D738E1B06F9775120A45647C42F14F045A6F7AA
+ 03DA4F9860400592C5AF02C73015355AF100944F63550F083FADB82BBE9C5EDD
+ 8A9D7AD4C0ACCD7CAC049F87C1F509B48AA2CA21B707D6D447D06503F1548169
+ B4235CD9B347DCFA852B6F73E4CFBF4100DC8239929C76D54F3CEF7761EAC4BB
+ 09C0F5C97D99B58130598A8E38F765C06BFC486347D778DDF6AC1890487F5B86
+ C0E174A0341BCEA5BE95522CA1FF579A792565A641483E2185544F9FA6E06385
+ 352AB9475D1743DCCF596A23F1336FF2E4E5D346A23DD9EA598F9A245FF906CB
+ CCFC721EF1BAAAFB3D391D53F4A6A9C77DD654CE6582836AE78DCA2089786EFF
+ CC3F84E14F4D0CC6EC644A1E04AB73D58A9ED53F8F908BE01299AC4078B30FCE
+ E2F2A6654C51665079539B83419F0945A473914736C0DD3BA2F0FA70E675E647
+ FB56C359385B30900A94CDFAB904557F8AEAC5547022D4E90CA850E61BD0FF88
+ DBE46A523547566F408DE838A9B2828ADC2103397948AA741ABEA98EDB0AD6D3
+ 9919FC8145DD5DF5427A6E90BADA681308AFF8CAC995153CABBE5B867891948D
+ 562AFE6DEA78AE4BBD0313600F90262E8EF11FA6B49C1EF9F9E75A5754BB2CE9
+ D5C11F00E2C555EEF394D4B2C052EF1571D6E59172FB6C13F5288692DA676F53
+ 5D39416528CE785F961546ECD72B89CF89462D864C76B2AB7ACCCCB176A14332
+ A4FBBE46E1541332286A4850AA79DB782EEC09DD54ADE20230007D47209A2E25
+ AF6B16DD39A21CDE6C802CEBF44356FB73904CAC39802A2578F74665F6F8A0AA
+ 5E915FDD299EAEBB435C9D6A1EC32865D3EA66AD3E1BB09A8BEA7E21D41758E2
+ 19F19D5A2B76BCE7842735B02548FA1EC464AAE92B6E1C0353DEED9FAA744BC6
+ 2F9C3882353666E1B8FF4AA5B391CB8F06A48A0AD72CAB1D15FE3302C555F894
+ 492D16AA7F2D327E1A92C7375B605217C3BB49FAAA3A1B64263626E2246A83AA
+ DAB1FA0A7B0D24ECA5DF3F66C627831CDC3A31AB96AB88DE8B368F469F2A41D5
+ 0F1117FA34E2D2756F4903C4FBC781B81E3B4121D4A594B25050289DEF929737
+ 4A0ADCD399963483F8D3ED15B295F863E273D70163C31F3E7A9D3D334AC5537E
+ BDFB6B2D00E8585CB1DC8D0B1E6D8487EBD4A6229A0016FDDBF96435F380EB2F
+ 5C5F697DB0FD153AFE45F743E734C5529DE138F0AD25C95DB3B1EFAD5D05ECA1
+ 053DF768DB4FB27BC1D58336EE1EAB65256F59EA4042DCAF69A2F2153A798A8E
+ 207F48280B8A556273A0E195D8A804B0C934C4905D3F3422B481C4C26BD3DA51
+ 50DCDF6030E333F07E9574EC15A8C12F0CB81585E7F93C3B0E356483E36E0179
+ C62DE6957EAC21A7CA211AE88E03BE3D8320FBD966FEAACE7F3D4367EAA6E526
+ 1519A49D24FCC6C4C12F4560F65FA0ED6A3361D10EFDF4CC4ACC69611C517E2C
+ 97B079300CCB99C8DE11226178D21E0D7D56BAE4959B64506A1107BBF0CADEA4
+ 268DB421C72478BBFA005507B1F56F788AC215516ACEEE47365D4C34FC94AE7B
+ EFA6A0EB2376520D7ECEB5212AC2D3F2B4D30C2CF717B9B061EF3E4C220F1005
+ 69D11FD03B16B2F3536C8E8D12AB90F0E7EFDB16EB1B6E66E26B1781B6DE7488
+ BEEDF3E394EB6F91CE8F60BA4BDDF9DDCD7CF1465C03C3B9763CE5DBF74AC5D1
+ AC542945DFD855CC191F1096AC9B8AFF29A126CF14A23179BA2F4637F55B7A00
+ 4E83BF6C5FEE0588CD7CE828C80D28E7207661DBF4762F4DBE1028A1AD0A51CB
+ 750A61E647D207E704AC1D8B25261CCCD7D60AF3394016E48AD0A3B5F9E2ADD4
+ 0065A6C6008639D207E259A3C7B54962F970E9F6781DD46D227A917299431611
+ 2DD6CB7E2F34652FF5A90F3F0E50679FE83F49CC0079F5770F75345E9DD96938
+ 9582AB2516FCCA8E58D8764B16426D231B6F04C68F33E3324B2114CAAA457B2E
+ F5538F3CAAEC49A1ED6F9BA57CA319303FC6B966A523C244CA0A60355EAE8F68
+ CC0F3C6EE280DFB8804AB1FEFC92EE790FBED2BDCB81201289181725B21A65E3
+ C4851BD3ABEB36540621155E81B58D9050F91049A6C69252899E5338DCEDE506
+ 64392CD2C6529A3A77E17889D5312EFB5A2F90A50224B21B71DCCE835D0ECABF
+ 666C9A929684A70781CD137FA9F9A699AE8E006324AAEC7126F4A288B54B65A0
+ 0476D964350E27C9783576342605BA8926578AEAE351F5300BCFAA0018292500
+ 893F49D2B86F9FAADA73FAB0A8B180A96D7A34C9B901C84D9300655F5CBD2F0C
+ 41AD9E180BF589DBF3871EF2F0902AFCBAC679BED7026E82776A2C1F2512FB21
+ 2025D781E976668FD796CFD919B4A3EC0E317A702AF5707AB6B431DFDFADCC21
+ B9AEEBDF7E7F22009155A6EFAD1DC3AC1A1D4CD41F3FD867A72BE03CB73BA5EA
+ BABCC76EC324FD5444FA3FD4453585AC683D4ECD3F3E3D0EB704A01DD8006812
+ B4C50E6BB12BAA8C2F003A5A1F9E526E975DEDA634E914A024BF2420AED22B41
+ E0DB3FC08360FD22732FDF4B3D4A0C2DFE90EA69497669BD832699ACDF7FB4A0
+ 183D469C31F0BDF6854F65C839DEF08339C35D7E734360A0A7939BF66597734E
+ 321DDDBA3C0F233D53620BBC8075B082D77A133A51907FAF5FB8787F3BC157F0
+ 03547DBF813B477ADF724CA09683704A94FD5E0E8C420FF273CA26B6783B7D8F
+ E4B544DD54FA57D615B990AD6E9C17A1D85C060344A8FECA828FDE3F06BB9432
+ 4C221CA6C00723953242AB61801B25F9F93F59BC2334E26827E537CB996BE817
+ DEEEEBF63AC6B7DB3613EED54B3715FC83DABA46CA1598CE9AF420D356919E32
+ 948C6BD65AA2C6F09C2C302C5328AC0811BF9549156ABCD42F24C26E45FB413F
+ 6265BFACB04FB4D5EC2B20E8F165FD99C6E54F6CE07F0DEF87155320572E6BC6
+ 1CB36577E3FCCD058F19E4784AE5B05BCD823C1F4B48360B6D600288A3235592
+ 406206920F40F1107E1010535284A513483BAC841D80990E19F99A073CF2940B
+ 7B6E61F9A20B78113D468023F9FE7F5B8B2CF2F4B82DB05D1189A5CB286B7866
+ C5EFC326FDC975C2FCFB125DCF6CE5D5836FAE7F661D731E0FAE1559A656EE60
+ 8EA0909AD4E8969546E260BEDF60244BF7E01036B7B89A38088BAF43A41584E2
+ 584ABCE25352CBEA09B071D72A0621867A9AD2F8A451D2FB87779D5820580BAC
+ E008369E19C32347BF1D4C6FA9719940C1064B5AC7F4E71982524D926D9DE5D7
+ DB73FF4AE22C8CCEDC2D3A370E0F8217B23EA40F67C1FBE8B929B124B9373CBD
+ 02BAA22F3967C40ACF692E7E29968ECA3DBB336571B120B09DA6CCF7D845FDBC
+ 591797FCD09F102DE47D8F59180E5CC1E66F855EF81A2B5A3BA37A0F52DC9326
+ 9F67E99D1345D2BB934CAC167D6B7588796549C1F86C43FC9F610F1D1D9DAA6E
+ 0AD352A2A61DE1548009C0BDF4039C9A93132927FDDF8AAD89B358AA01D458DB
+ 8C8B48D7723C7B9162239F34175DDE2DB4A1353D30A1C1611FA3BA3C42C8B677
+ 16EDBE82FD87224F452A63D7A03BCCE53181519A1670418D1FBCFBE1924CCE3B
+ FFCD1E45FA20A0C59C47843509A28B36F590A244A5B021F9C2E76058747AD032
+ E02DD80BC9EFA93779F09E01DAB84DE3C745CA3AFDE453735DD32E4B1D10E410
+ D8490CADFF3577AB359AE49DAC0292B02356C1C5F432D930AD7D8216C0EE7F3D
+ BA76EC217D9DAA09D66ECDE8131F94EFD187EA5AA04EFC13FA1674CAEEC7C2F9
+ C944325522AA1B69CE294508F614FA63DEBB11DB6B455440CC7A62C729875B0D
+ 25EF8793EE22E36BF3A3F028BABB6336EC342C2D69D124D83AE363262953DB20
+ 97ED4C77286438C6E5F63BEAA697E4A5CB6C3C5AE3F5A42430324E8915F59B87
+ BBD3E12B67DCF050B7332A6F0938E72E80B650CC2165806605644A788B4EAB7E
+ 723240631F468317D11B18A542A5E3EB718A8F118831CA728118E7576EA61A84
+ 5F2831A17DC603A8ABA6BFD8E4B08CBE565BB3C0E103FB9525C76A2614555D93
+ 3D1537B3C8E990292C12482FE9E3DAF06E30483BDD1E65FEBFE0D0E76992FFA0
+ 550C6E110B8712B7D3452F8DBCB7AD91A8F25DD70F81BE7306B7736E11EFB269
+ 14AC195CD4C67DEED023F9BE658806C4E954888BC93C4E85146F5CE8C6BFA6C5
+ E7DADDF72DCB444B8D589E2BD7CFBF90C916D4680560CA5BAD2A0251F435D64B
+ F7B32B4E5BEF79E594E4A829FE91D56C2ACA4E0195A0CB801F75AC215AB359E2
+ D8F7133EC238512D43D9DCC206313029AC22863D3F814DF60CD0908D7BA50888
+ EA5D793A8A5461FAEA2777D87582FDF21D4AE5FC77AF90E70004FE055924A487
+ AF3E67B42AFAB309CDC514B2E768E6FE8837217B1E73008AC23FA71FC15701B2
+ 430139493601FEB2BFF6728FECD54CFD01E6A46D4EE8E41438C62DEEF4060DC8
+ A89690F9158E128895448621D5EED4E37BD13AB069C7EDCC59262F8B1DA6570C
+ 745422CF586AD050F8C9A7C937469FB970F68192398876468E97B42CA45EBE15
+ 2539997829DEEF9B67CEE591FA1CA7C6AC6A274116930B9938EC2A53424FA9E5
+ 68044088EBB5D0E6852376DDC4BDDE1C2524C9A6F6B5611A78D33EEC9F79D0A1
+ 3BC4E47BB438BBBCD5ECD48954E7A12AEB9E4BB5C27DBBD58F84FFD7F02792B8
+ ECA48901DD26A46EB96B972C3E7A8DB4B800F718172AB38B9127A0B8C2F2080D
+ 01FCF2BCB2E2596E4C0BA7C74645167001AE2D8C150A42D30B1C40D72D2EBBAB
+ 45E62C36421B6DA33143FC4470875D69B644759412A36DBD669057B7DB67914F
+ AAB851E571F82D68AB26F29955148C7B0D844BC6CB53C9D7A31A3CCD432D70F3
+ DE6954B07495578F64D1908B403F29B56D56F5289EE25C231CD0ED58FA180F05
+ C411CDE40DBCCA65D560B4FD6231DCB8CB8821B260E2B260F017EA19FCC4155E
+ E1CDD9AB97948ECFB2D22CD11D0402E15F17C8ABED588499B58191A945D38638
+ C06B19CAAA875B26C570100E4FAB6AA1C3C267CB745E4CDCB9727711F8A59036
+ CFBC3487453D48B81ECA3EB4158E02C7136093257439794D437A4AE7CF8ED113
+ 81068578B00B5AE3D6773E5BF075EBFBEE1BF4A79C9CC4D7928B465BA2ADDCF9
+ DCA74AD67BCEEDEBD401FBD8F6A2F73692613960D228296B5546065876139ADC
+ BC02B80DFB28538C62AFDC46C23C4C101A7A70B64934ED8E457EBAAC9E22F7BA
+ DCF2D01C79621303B157EB374012097D607F9DB1C16BEC8D01A019C2BDCD2540
+ 2A6192DC58905E73AE537885DE9CB6B89F9C8C84B23DAF95DF76E356763096B6
+ 920899CE60ECEED24D5FD90A7EBF92F4509B93B7C44CD9F8D2BCDED5566F103B
+ E8F1530966CA963813365BC8F2588D1B2D1CB6EB19649E13BEC0D88898DD2BB3
+ 0E7F66A35019B057B6DEE683C22D92611074D714B2C4416FE521B4379F39BAEA
+ F1389C73D3F700C4C1E1CB5D2A3E3DB5E1FEBF7D0E778DA2E2D3440F108032E5
+ B3E59D5879042FB307FBE22F3202F07ED3C751AF30D254CE80B1C88C7E8102CA
+ B8727DC2F452AD3B90A17847F07B0BAA1B37159DC84D7B040341D7E1C3AEC0CF
+ 4806BE0420F1CE1BA3080E37B673CC37E2AD719EBC58E6F959127E5D50D69929
+ 8A816969C3F9B19C32F788424497119C1F1A266FEB4DC536A14F362C0E143AEC
+ 18737958AFB70018B943830D5A11DB7294BD01C99F2A69E618326D9CE25BFA1C
+ 07F23BC65AE6A43E454B43CF61559ECCBBF524965062AF3EC7AB70596AB82436
+ 26CC7CD009BC6C4A34A7B76B73A5AD0B242AA9DC3D6D84F97EA8CECF522838AE
+ F02EB4CD9CE997C55C4AB706377B793BFFBEFE8CC20F5D9A765A558C66A60E72
+ AFD676009FB429CA86FFEA4E192E5A4EAF9374F2EDF56C64F9860BD9853DE711
+ 52CE41BC70BACA75A033AEAF26B1FE01AF0F747E1C004C83E7A5241E8C52E9E6
+ D8F409F95453F23BE62491184CE7305803B157E073ABC39C1C338FED6EE86740
+ 6015DF4D26D52FE635E31271ED54F352A5066A7E8E68ED60B549FA4B9017A6B5
+ 8657DE061E28C43E443F2C898A55AF915F31CCA62AAA4FE51C6C4FDFD19E9F2C
+ E1D27A6A256A73667D799CA26D427DDC3724372692A304FE012D7DAC22996B41
+ 35917EA895F410230FD380A4D556F33871372580A6317F6248E5D92905EC2D50
+ CB7AB64DA92E986B3055658826443F97B7EFA2F64AC82360CF0C5BB5F87805BB
+ 9908960A7E3DEE2D173E6E836FC322D456DD932DC78CE4053972502D257980B8
+ 39C3121B5BE8B05033B602F82B514CF8D2F11AD0D03228BC9A079A5C99267F78
+ 120D33F70C7F1558CBF7F3C1122222C208CEFAAA0CE8E1725AB24E9DE31E2A92
+ 1C2300B01038A4ED6893EB4767DFA899C3CD2A06F33413F4D0D399D592A3C8C3
+ BCFE01C8FF79E38028B1ADFB7D7553168EA5CBC134352E189177C374D6C84815
+ DB69EB18AFA27B283249D74178655C86386E6ABC00FFAD3F44BC9E125A103003
+ 9B35D838C294C8DD8F0378ECC192B3408E5715F66B6A907719F1B10720D9D380
+ B6805EEC2B9503186311FD4AAAC2A0706DC824DDD419B1FADD0BEFD7793ADB6C
+ 7EAE0B8948F5CA37D70DB10B11A1773940F8B4C90D307B1914C4547F8D8B7428
+ 93485EA406E1D82F79977944B28F97C52CAC516A7B19F5443D32DACB70AB302A
+ 9F62E55E7EAF544F3DFBF9D2FBCFF88527F3DF5C8F5EB4828D594C5D03C0B278
+ B52D33B608B08F4AA14154583E8CFACCB817CDD24887E6A0903EDE16A46B2E50
+ FF08B7FA08C7CB2CA34D367C45ED618B976043CAA29721C2527705C13B15A988
+ 140817F436B5517670A59C85DB53AF77407BDDA580E1D3954A49DA2800210BBF
+ 673EA61974C51C4F40A8B98B48BD7B8A9EECEE57F8DB4472D55AF334050C766C
+ 241D2AF8217F784008488AD99C799A5679E10DF8AA1552C939888602DE0AF22B
+ DC385265D749BB76B9963DC1911DAC2B3E07E77A76EA180A1752C4BB83F2E521
+ 948D11A6DE5884DCC19BB357594ED150BA5A977EF339CB2B4D3737AAC5685C23
+ 17663EBE424EF4C3556ACCB485A48FE9C8BB7A85546E6CD28947EAF4211851C3
+ 533FD866F402674D1BEF467133E8411CFE2FE70CDCEA71E7F19B0B7B50C75BFF
+ 5F45E24265A7407F52552703454C6DFA96D9110F4F622BA64FE0F31CB772CC5D
+ 9AEF134493190864443DF4C529869073C8FFC73EF2F153E68FDFDDD8EF0A9AFC
+ 7AA166B21A6DE3247B55650A0252749B7CBDAA23F28C116DA1C139BEF6BE51FA
+ DC22BE77DAC284A845BBC0C7BEA8AE1CB365770093E905C4F65C9AB8A6FF98C8
+ 432FF37B81FDFF020607F23532A4B930981C1CA93336D2F6D0E51F6053B1CADB
+ 6F10A17D11BAEE36F50603AC4E0003D10338F4110119698DC00B164403C86118
+ F348182680DCC826E67793FF2934EF97114D8A4B8413612CE8E23FFEDF24F3DA
+ E7B4384E0BDD0C4495F56982BA69B73F20307FD5D152F791E6229B4FA564165F
+ 9FEF990C2D1B2847E2FF7368AE6CC10F1446F73AA691E867C63C71ABFDF8882D
+ 122BC46E4521990363DC25BD31C96732A492FFC7051F08D6BD18B9A48EDBD4C1
+ 0A4BEF40B1C5E4FE5C6F114EE86BEF0CFC88433D5DFE9E99B9AB54E7E827AE9F
+ 0116E33C0E06361DAF92E01C390DE63F7E7CFD89B504694886E1618EF4768CAB
+ 996C59A94FB6F2FFA565B818B12C50F73D74C87264419609E599E24EBF04DD2F
+ BF77D61458B820CCE75E0F1930B5478DC49CF3EB534163E0F7AE23CD7B2A6720
+ 66B2001BD569E90AADAA80AAC81DDCAC98E4E1C0B686BF71B1E18523C6D3D2A5
+ C0B852E4FFA3B78FBC04DDC69DFDA8BAAC4BF35889AD949F6022AC0E41AB05A8
+ 05E919B3C9981E4145721C0A17F18F1DBD5602B5E6E3D9C4C1FAF2362C62B13F
+ DA08A8629E169E66CEF5986680B89DED9DDC6A90FAABF545E3F97C3AB75C4A5D
+ 6997D7D29CCC443E204C85F3B435252E32CB8F8EA2ED3427AD3656A7862DFB5D
+ 1FBDA1C73C39DF2FED3FB7B84F5188ADC87879B5F65CEA55C312E96480F7C89E
+ 86BC5895C5A2A8B6C81361C11F64A2D760A2F580E93592E0C7EBD01C34BE1E39
+ 63BD06F81B86D516180A75A5CDADB22057C5FB59E9700549CA6371322394D58F
+ 9708AAED7276B8E6285466F5547DCDA158A817BC3565D93AEBBBD1BA7F19628D
+ E836CF1E2E7AF20B94DCB5A67523DAFE2C893A4A61AD75A22A1C0D487611F66F
+ 9F53EF2857AB19D4032F76B701BAD31838958AF9DC491B185379CEAC62DB3C6A
+ F8CE103E64A8957CC7C93D5453E3DF659FA641F3AE53BC383188D9F1C1440964
+ BB22759A021ECBA698DE0D602F167D7CF19284FCF346DF86B17019DB050D5ECB
+ 580165F668AE808D6BC17B3331B6BE076F743CC66135DDEE9263940A997A8ADA
+ 4A72AEC708615F9FF2431BCFD994415E74B31EF69E162FC62BEBC77B181BD1E5
+ 764947C77C837355263BA9110D331E0B879CD1B2A9EC9DEB4133F16A89531259
+ 713075E0D0F12FB5F6393FC0ED64AA62424ED4E13BC0BD543089AB23D269C3F6
+ A1203EB8CC41142649D5853927256C0E1767D5A9BA434AD0B7B7B48636F8DAB1
+ FEA44DEF33A5A62A57867EE2B5B3979F363CC9F8FC3BF0D5E2B46889DD8573DC
+ 16216AAC20BDC6F75CD12FABCE5A08725397D55F682E093D8D46C0B7DC8A837C
+ AC6058C57FEFC1F6E7E9CF2CCE16DA61A2A44FDC2DF086300AA933E189B95BFE
+ D0F50CC71C8795EFF7B9BF0C8E4727DEF34D93C3CD2D288AA17EBF3C6D6F353D
+ 70C556AC60BDA05D286B9F0CF24DEC71AECFA3DACE10FE2FC044EAC72E05FB1C
+ A96A4D27B25D80B57A53A2BFB38B6A07F7F0F81605CE752AF32EDD996DD67BA1
+ 6945D4D77CB0B597183EE23CA35FC1EEE68C4B94500D4E9B1301AF07BD670C0F
+ BEB578A2D82CB1699DDDE5BAF4D36F80014ED023052ED7EF8D6838E6C3288491
+ 6EC846811A569AACF77827F74E454C1008CBFA7712E0AE61671B06D011C85D59
+ E14327922645866F07893F5B0D780682A03DB683845968E5D214730BC18902B5
+ 863BB8C2E0C8070EA7792521D1DC307AEAA7AF791D301EC396E28FC72853C04D
+ 47D443673C2C7044577F995817040A9325F60F1DB91553C489121F1FECE72F8C
+ 4E698E7B604CF39665B7425D59240B539935A309D1715407D0623117A36EB6F3
+ CC1593265A3461CF36621DCFC8FAB32DD54B29E0F192559F116BF787DBDF1B94
+ 738488252339828E9EF62B9719F4E1ED7FDD1129C6C6333A3A7911950FA1E457
+ B395E29109A78DAD63CDB5A1463FB0CDA6DEAD82C836FD6136280E08323D8C44
+ 4417CFCDC47E94212A919F93310A1B0014D70BDCD63A7579C88292F4B7C31B1C
+ 5ED782A1C2EF116C7CD073FC0D5CA250E4A32B6B4DF71AEF9C180354358CBAFB
+ 2C9A1894EC4D57A7EE57B13ECF75AF621CE505236355691030980FB1CF32A0A0
+ 2C34E6BFE7554B512878DC29B95F581FCB65166FE19F2A553FB4ACC4E1189EB7
+ DA28D9F874F51CF24AA01B9865755815ABD333FCBFF0FA895D508F7FB561B061
+ A7F105CAEB8AE724F68F630CD2D90C0EFB5505FEB4CFA1353543C7CCC182DB9F
+ 5523879F9527DDF82C33ECDB9F1663F7D3FDF69D4F1CE9E03815B1BFEDE9AB25
+ 6824BCCFB38902C3B1A38F9A6B13B6A44B5ED7BD281E541226F7B963B83BF54D
+ C542396481F42DF7506F1BCBF63599630CD59C3A40738E9883B86D2434FC7482
+ E9899DC92628D06EF8DA8C24BE409E7FC0BDC0B6C7FA6FF8C59A695C696EEBEF
+ 1E5D69305FD64944DCA790C8D3A666FA437AC5741A256CB3C1B46448CD686855
+ F5A4AB4A4E99EF68FC9A976D6C07FE871610F76B9591D18BAD941546CF8F83AB
+ 286235314433A1FC7838AC23C5B2C0D20895009FB3F98344C4C310CAA21F5AD4
+ C5FCED00A9DCAB7B001432B87C7F9E9A6D2D0271B5BDB953E3D17FAD83F55EF4
+ 05312DAE066C904BFE5A91B961394DC2CEDDBF5F484DD4F96D291503DD99EA93
+ 51EFC7ECE131F9F0FC8CFD762F0BEDDDE947D7CA39D02F365DE2C5AC7033E7E3
+ 4670A78D170D08F03CCDF693E543522BC2B0382CFF7EB9440DC480E87B2927FE
+ B74AB44B0C1E30ABCDEDD5684819D4E9B0F8300845E2283EC9D467F77F59FA59
+ C6E336B895BB790589F2054318130E8107F5F273A9906FBAE5C70B765321C728
+ 5442DCBD9993675109DF15D640B631A049F1B7A5E8E952738AA77F5C3F12422C
+ CEE7ECBB620B2B1D1A4EE84AFEB0BFE4F11000C6A044709138DC1C59D18135C2
+ 7A20BE513F6F3018DDBF51A01EDB0E1C4A662260EF1630A4B82CBD455C313076
+ 93F27BE648C822DF8C0E6784B3F6BB7B8B0FFA44F6E3B896B81F099CC71EB7F8
+ D55AEBC06A1AD437C4F35D949C0D401DED3C7F18B72707DFB3AA828CCBCB8CD0
+ 76468D33B80EDF0A613A048645F06506994C7813C158949D41D7D7EFFDE1A88B
+ ADFB1AF2E1D18D4DABAD3B1E3E88F34677CF7176B335FB031D6214CF676CA475
+ 55B7A7796B4D75A5023415563A65055E01C0D79625F4FB111DEC72A853653D83
+ 8635BA022B128B737ED576C297B0AB632F509D5B25DE8D5B2ED17EBC534F3FFF
+ 2A13C397796690CECBEED74AF41B91185E2F6FD29A8F53B5DD8CFF4A2CBF53FC
+ 2E08CC35C0250B75084BDB3904D1CE02D60230889CC9911794499E0AB1B01735
+ 3DE36574384A29047DECE4F915A41C8B20B30CFC06FE2FB9B45AA05D69348AD2
+ 7C9A23A16937CCFDF11DA17C6CFB465845ACD6EEE769E0EA1451BCD3F6EA5385
+ 9ADA0DCFE6E5090124BD74927ABAD843D12AF12E38C06F83247169C712A83928
+ 32990D012BAA5D9C1C57F8D16BFF2BEA55197BE65CC77B693B505D27DEA36792
+ 8D247E10DC87939A302F031A82B6F3D226AF878A02B7F01A3CFA6317416F8BD1
+ DCC4BD7EE20F48CF0D8CC50B4F511D2FE384DE221E83DC2CD1FB903207F16F3E
+ 001CBBF7C2C012F3E6095692BC18C6BA8182F5E84C43194284195852B721FBA2
+ 814307CE49F9008FF1C035DBFB1954E256741466F51A1A06B80B1BC780857C0F
+ 110A8B0AA2DAEDA09AE3FDECBDFBFBA452E9C3B126D0ED0460AC4B175C1F96B0
+ 551BA7209D17D119CB0622378E91A86458FC4F0D8D33AAFFF69B2FFF3AE3F7EC
+ 17250260E241525C0D6E101146D742694C001D94C485972E457812CC9C432E90
+ 0299C1F1B7363754EC1F2B324474481DBD93C2F04F28195A5F6F58AF32DECC82
+ F991D4F5A516B448004A290B63AD108D487A9BEE8BC9AC16B93D9D7C061F2655
+ 8118EA44DBAB0024B7764A10A60F1F14E9B4204DE1B85D83C299C8FD5FCD0D2B
+ 7BBA04CA41E75A585662C0C1255027FFA2C5BA5F7DF6569411BC1B684E1938F7
+ 656D7D41EE422F93A9DE917A8FAD767A1B9C216D267BD708437110E1D128F3D7
+ 7EA52F514F8CBECBDF36D7ACD7E7082C61B011F7010B6A95F33ADE3888997795
+ 791A391C68F79648774215AC05B651E9B3BAA4D271CE60DB8504314D5E1A1473
+ 9F7C1B710D8639D07E37913E15F53D89326C2AEE97596A4CAE989D073BA0F6FE
+ 6F291EBC027F3128D446EBE2DB22B3AF36D91B494AC7304E2489896775014661
+ 63E9490DD85ACDB67578B3C2FA4DE1A1D923C105265CDFE4CDA4CE0E0541156A
+ F626EFD30FAC54D612A8E5FF726B189E78F252A44D3185F908E8BD66FE6A51FC
+ BC27B44692F2E5C695A63F7D190070E1861017435D1D6C5D8652050F90F9E822
+ 66761BDAEACC3A25509970AFD9D80E1A356A9EF576C0D1BE39DC31A68F59E9AB
+ 73DF2C7867E2582A796B1F99D782C90CBFEAD6A0A6C3C27F8CF6FD0E573A257D
+ FF7AA3786DF2EE068C36CD0ED8B06D35298F93BF97B94E3C9B314310912FD61B
+ A39025CB645A00FF32339BD2B73B5F0D2B568B3489CC5D46C9E1435E75DF87A6
+ 47BC136CEDDF5CD2FA89ECA5DA12EFF29F8C3C0657AEA7C515E95BAF0BA3FEA1
+ 849195D0B955EDCAD78FF07AC66F9DA282C5E285778F77FD780ED5948BE64F67
+ B53389E3F20BD6F8DF92727AB7DF10A21D864E4F6B28AE15391B2224BE4E31A6
+ F0264E892E7789975682D3D8FDC98576EB64B907B1BB09BDB43DC5705ECA02B9
+ 5B449A8037B39040B79FEC27DA06A70B2813382935A5A7ADB34E438247F2DD55
+ 683A2554F32FAE47A527C8D6D3D03AC313CF964A4330E3B7EFBE7C5785465C0C
+ 745DDB32CF47B35D9C4E3CF79136A8451A463403110F9EFF655BA264F6E85C5C
+ 11A5F53FD521B6C4D08D15DABB155F86ECF1878B1859FADF51ABA367A3464949
+ E171A3A1ACCFEA2D3B5E16226DC82BDA4AC11B60C408D12697C15A7CEEC8B88A
+ 3D77DEAD7C0688D18E1DFF4409921E22391FD0FE63E19552838B142ECFFEF01D
+ 96D39FD0DE369DC698A2F3439C08C0063DB3C0EE9522744DB2915C4F8B96B205
+ CA46AEDCF513F1E6B51F84CE614145E4D4DCC76A14B5DBBA1C593F320464D09D
+ 4609F44A3D7A86A1F8361A37B92B101CF7768FF88781148D885E3C9865453E71
+ EB9C6EF8743F8C815F4959EC63923B75966787EE52D2354D00C2DEAF5BDC95DE
+ 1666DA7D29EDB2C66F031A377D6DB8221173AC49B6027ACC7B46976AD51E9072
+ A9997221E98159FA9BAE00444AE6EF09B8459D5CB11E63F43DE9982B8CED9734
+ F0543C01C258FFF241F19A73E4B3A49C47921647EB3AFF056E02A30AA97F9250
+ 26FF9A4D968E70091B74BCED68A5184D953E667CC623113AB4A325CF8C151F6F
+ 89D03F70C556F049D502701C082D4E918E1910646F00CFCA08F24C07CDB51CA5
+ FA337A88B909A9E6A8844E6F3688227A26B33EC0BB7B9ED70EBC8CB77686FB38
+ 49F0B39DE6854A53E2EFE9E61362C4270573EA172AF8BAA5931C0D1DC6A474C6
+ E1022442BA09ED8177417826757F53412FCB27CE31C45887A622AE808CB9E430
+ C56CB3F6751EC3BC8BA0C3D05C2285AB8C444CEB3DF842DDC3AE382B6E65094E
+ 33871B5AC5651542573D971B3FD5CA8C3B54B644872C531D8BB5A926CDD78D9F
+ 1981B89C48FD12ED8B067B540F02A243A538D6D15C607786C5BEC9CD34288DFA
+ 88184BFADD7CE5983DF24FF8EEA0EFD1BD1E5C683539E9799DD289172AA87A0B
+ 18B200A506F264C2F14EBBF2BFB168E0F3BD37895225EEA19BB98477ABC9D9BE
+ 4D3A12A376FE6366131ECDB9CBE0CB05BA2DE140FB789613C32B167273EA10C8
+ 426CF90F2A88BC62732AA8BDF33E460C9B73B3F5E46DB2CD0455E0E511E3DD51
+ D0A98AE7F179FB36FAE116A36C36108C0FEE1DB5F125CF8AC78B55D6ABAD9B97
+ 943604E707C451C3CB50714D79FEA45C458243F803E9621CD99E7593FC29260F
+ 8E54FC5DE717B3CAEE1FB4743D6A5358242B757B386BB996B9FBA2F9E6D7AC15
+ 6CDD9B03BF53B9F229EB5D779BCFEB97ACC664169FFD30E04205A4D14F319AD4
+ 2C150661BD419AF06061E0D88ECF308CE26E85156AFB4577500453727E17CBA6
+ D47E614CFE93AB565FCE54ECE7000D9310E4234985C4F16BF70FC0EB5F60A9DD
+ 10B64321A5F4E652B42C613FC050864450DA176712F8BFB97BD94BE2008F2008
+ 55963F346CD192BDF0DE185E3F693F511D76D95A345493622F7FBA29E1BB04B9
+ EB8B956E078EA6FF8FA6728A7C477A6EF3F5349ABF5D16A9F5EF1F94CF0F2A9F
+ A5ABB3506DAF97F8390526BD6501D6E8BFA62C1B6482BD789DDBDAC7485BE97D
+ 977F68F76784168952107D3B0F5CFA9651D750900D9C08A6B81C2FC282B2FF3F
+ 2319A85DC550FF3E352A8C00B5C82750ECF64BD2706AC7E31BAF2CB7BC4FB3EC
+ 7EC52276131FFE18BAF0DA92F181CA114DBF3C760F56BADEBA8CF8D232A6B75D
+ 1101A34373C6C9C52B8A22F4C0C20269615D9BFEBAE4F7F9765EE8F62D325B05
+ 5979189A125636083C90C698CD313E93B155E807EAFA999379667ACE1168DC95
+ FBFF5FC1A1C806486678A0AD249284BB062CE4C593C2910AFD433C231F8231BD
+ 4BBBCA59AED7E2905D57CB37DC51D81C9C53FAD75CF9E8118C233A9AE43A5E31
+ A3CA1696A31AAE531B467EBA3E2DB54CCBDB9EA5D6279AB802D51A19FA269E11
+ 686DCDC5F4CC4FBA43EFB72DFB13CA12D522E44972A932E85A7588EE5DBE5E38
+ 19788596769D94C800C6CD5C8DAE45DE5668B2EADCBF7705D488A9588A4D8736
+ FE883DCD471C60F6D05F70949BA4198DDD5F155B4C0133E49EC3747AA34E5AFE
+ AC3AA4313257A5EE4210B56DBD0271348A6A40ACD43622648E29D8A39282779D
+ FDAF2463142637B70BFFAD6ED3C25D1C2A0D725774D73D9830B87BB4D690984C
+ 5B4A9AC627F3AE6207D81B820CCF6B614FD8922D2533316FE697666CA5D9621D
+ 279DD8DFD304E8F1A8735617810E2A16B38DCCE61F3C934E957826825D581368
+ B9DEEF0904E34CF09D7AD9EED85205868EA29016DD59B296EAF7B4D0BA3D9F59
+ 3AC9D4EE2F66F56F56AE08BED673010EC5B87015D4DB7B4E8E88A741C66FC54A
+ 73AAD1C15ED9F6E9E8D56DAC4465F9A21ADB0539EAC90A3130B24B7B265CAE5D
+ 0084906945C4F7F17246FC0D7E879F9ED82478F1596A0FA565E13550EC528992
+ B457E895A7C5ED16CFFB0B94721B402177D0F8B9B98AE0CEA69699908DFB71BC
+ 0B090477C1FA3B64D1942B237788FFF3C127E1966B6609BE4DCCC34570F17938
+ 42047FEDC5675CA666147A50194A904FE92C8BF9B68AA3569493A0C61CA3BEE0
+ F95F84D4C6E9C7A0B5CD4A3DEF29207BE9CE84E61E0DEF4D1861289B77B5A591
+ 072542C0D7D945DB5BED4116CD63831C94498AF107AD32A8353E83A38E34626A
+ 22F7C86C4FE20456AFD85323E0E107AD2CFB39D7D0DA0A0705C8EC598346F494
+ 77CB867A477E10ADE6203FA7AA30AA3A77AC8328CC696555D966FE646B23190C
+ 62354AAAF09B2F47DBAC8C768E6E7F9CEBD9DA9958AFEC12459C47825C996FDD
+ 4F1D1FD5B0615B44B36815CB792AC6AA380DACE4D53CAA9D8E90957148725FD3
+ 69997A2A2911C15D511625F391FDF4F01C11F59FF8F0D6898D393280AF7946AF
+ A39FE3491C57B66235C30ABE646AC8C77FCA3F2E7C3582CC78047127F043E573
+ F9FF2C37006271B0C32F9C4BDA971D2DB3C3DC3DB97A0B82F94918C167DB4EEF
+ 56C0EA21812A6B8958F2D8099CF7B033B1AE391764066A706EE9DFFA343E6C32
+ A886F5E3914192846E9DC7FCC09F3F318608FB37B6DB7EBF54F44599CF6261BE
+ 8ACB64F9B38B66436ECB366D2BCFE5F4351DFB29AB1F0A122659E26496E5CC3B
+ 72BA24E110B22571BA065B53C9FF678641E1F9C5F80EC317CB11458CF45C8E5A
+ 3AD767DF9B8F689AAA7F1A7A1FB544BB566842583409AF2EA3AB764C597345C2
+ 286BC9C00F28FB0D099E7CD923C4AE000370CED0CF382A8E299F4566AAFBD446
+ 2F94B508F386D292EEE0B1D2733022ABFAA22498D7B934153F3B82386FA23EE7
+ 711395CB91EA7C76AEC497BC7A09B4F8DCB5423C24841CD61681391D1F7798F4
+ 2CD20FE2516E9755FDC0EF16BEFC89EE4790950E9D77785E296528A9E2D8F3ED
+ 245C7D9CFA206BB01C50338244B39E0A4BAC3452597DB043BE4853CDC6352639
+ 4CBEA2F3FBFE0DBD46887DD67D0D76F4CEBE63818BB95D47F39950FAEECFEBA2
+ 49863133CC8236321FE7CB363945C3FA870DE7D54491FA3A7A51F59D0A922932
+ 703D3A6C2E3687E7A559FEAC6413536A358BE12B882D32AF24636D3F488539CB
+ FA676C8D7FAF1177DEBF000D6F176514F13C630407AC337C341377409493A5A9
+ 0EFF6156B9C84AB4874F92BFA23CDCC66A218CE14A731EEBA60CA5E518E368D6
+ DF27B03D7390DBD8A79AC3D7208B2F373901AC92D9AF3BCBB4308B32DDD46D6D
+ 459C8D0EBF945B4D2EDDF22E44AEBD279A13B3AE94330D7F18DC59F8B38DE752
+ D0A84507077FD9BA4BFD3DBC4EEFDC04FA8DED6F3E2294B41330EF67D6FC3EA4
+ 32707C487315685FE2EACCE5FC62D5F6F1E90F344D0AB21BBDD93586E5E8DAC6
+ 694B2FFF14D71946DB21CF13BF1AEAAAD3C03FE9363C63DA0FCBF63F8DC9056D
+ BC5CEB42DAF13563C7F68B19F265407F5A9CE954FBCF82CDEC41CE5152A74293
+ 2048C38D3D8F167253B443913670D9AB5AFB1F49497DEC3D5E6E13C3BBFDDE82
+ A71C91A1A005892D32C095F59767A94C73DE057FEB94FA38A190FC233AF06BFA
+ D50EB7DBF6E80531DD55135820AE62875107D491834CF00BD5CF67CE589868B5
+ 540B6AE912603C7AB304D2F5DD89FB67E0C037133B1B74EA84C0365EA03EB749
+ 4FED9C64B0B92587D304264B970D6EC7EFF8FA78AFB0581A8439A976328CBA73
+ F54945FABF7C03101B36C64EB4A5D71A1A06A682E6FC74D5F5821F563AAC9530
+ 770091F2E01E7A07A75413EFD4F1FC6515243D3372D888CB72891B62CFC6444C
+ FBBAA8006249BFBB6BC2C311C7CE3E12F2461E42C860510DD3CE80D70F8826BA
+ 7FE0D540E983816EAE4EA74A7E51356BC754BAF327F2F5F983269D96DF62DA3A
+ 117B13EF5408387A60F1D7A9B88690A4F8DF94C2E7542BF4221BB77BB94A53FC
+ C87CBFDBDA7AE674727924400A2DD43B98CCF61F167158D00CEE8ABA536CBF6C
+ 0333A35F3B2CC2FAA2731EE71E4B632B6FEC86B4A565660698D1F37880F48834
+ E212536E5CCD94792006EAC6FCAE8DE9CC743EE900B4E051D5460C2A750B9018
+ 0C81FC828A8735B4E4FFE07618839B5B0291DE8810229A8E099FAA9E3DC7E9C0
+ B814BB58665CD85AB6FD438B297B87BC208670DE99DC54B88E09C8A9DEF0D746
+ 2E1D26D27AFEEFE60879F319D059B1B52C8A163086CC573021DD804DDE44C0DB
+ 3B3985B01CB0CF68980FFE2973E349817E3A5B6B070197235A0167FBDE7B4559
+ 3C57F57714025D897783EAEEE53BC366E0CBC8B93480016E187336EF1A3BE603
+ A8BC6AAC0C09A4EE97CB9F5D13C98F9DCBF693B4AA366C8AA44EE477D5A3F6E0
+ 5D6FF3231C7453D7B4DA1263ECE83CFA1708C9124B43960748F0ED209373D1B8
+ 263ADB64C7FD673E53A874072E4ACF2ACEE29EFC9179D9AB236D65169DEE9902
+ D110535706523ECEB84DCAA991BB3BE9E026F65559197876C4F08D99E9FC8DC5
+ DB2F080AF7F90918523CDE2AF5086951C1A2934AF24ECE8F93E681DFD4F922C0
+ 0584EF5F2B9345F71BE5CEE3F3D7BC2EA1FCC22383D2F7EE03CCE8DD6919A5BD
+ 02ABFBDAD487851C862370124C5C94832A9A87044013C58673150A3C6B0A0168
+ 710DFB5E94B70224C8D92B8C47ADD1C47E376E61A291F09D7D17F33255C3F89B
+ DF76C67E4599F1AB9256887A95B5A4F5C0A5490792369678DB03F2B609AB3EB8
+ 3C3BD9859ECE7976850C0A80DE024FD752A469263C34C4BA0F7BA6EB4850F72C
+ 49F2F7AE0C2494447E024188E1A5A2C66AE00E9E1E9C3F5B6E9EB66E5DCF9DDC
+ E21F9219C2F2F35DFE0FBE4964C33ABA40C764194D85055FCEEF16ACDA4840B8
+ 6F38BB99CFFB6D23049FB5C580FC9CBB36536E8762AD0728CA567A0BBE876F56
+ 21D9A7611CAB5980A3BBD531AC624CFC5FE3A1A652C58B6657B51307861EB0EA
+ 60B801F1DCA723064DE958AD7178453BE9A85EB76335ACD9D08CF6D4A394B716
+ 199B117EA3A5B39E9EA0CDEAF907C684EB146E61256CA96DDD16BDCFA897D14A
+ AF73359BEC584140BD2BF4264985C649C31C66BB3B6A7DBE59AEFE829481BD2D
+ 34DE7C1B9BB23294DD84C25A0CAABB76ED036DB73C95C863FF658AFFFF783A01
+ 4285C2A0BFF97A503E14DEBB657E6A6B40147810030366518C1B6A557304ABE7
+ FE0DF49EE3265C9DCCC952ECD7B873A2B9BB1D2B0EDCB33B19301BB76E5607AF
+ E078C131151CEC4E5A8F597008190850536439DD63DD502A7728D8885D10E4EB
+ 674B79C5A10A4B7EA042AB6D7529D5EB5A65921C349EC19055D96003A31E051B
+ D250BA9799E169C4D525DC4C24C53254B20D7BFFDE5BE71F90B92E1E137BF46D
+ A542A2D6CCD985BCFC43ACCDB7C7DAE39757C7B2E3BBCE186C6836AFA0FB2973
+ 328B8295D3AEAA8DFF8A3823A2C7DB1A96B4FD4702F03C216FE8859CA5D7CA6A
+ 322C6642F4455E67A2D681E76E390F7BAEABFFA3D3A17AA665DA6079A82D34DE
+ 0A9DF14A576285960A4E4E1971689CF990B0ECD728782ADDCA51578C267863DA
+ A8FE549123537F7C0E4F8ED2D24BADFAD98C093AD4CC52F7306DEAE0A794699B
+ 37A87232CD3BE016A2A05F3569090EC4D5AF39632EA0C1FA216E769C48A15D03
+ 6B40EAE3DC6FCBE5AB524F2DEDC450407F5F2CE4112F1E6275E1CD79A5AC9831
+ 2FF65D50850980025E0DED96D7549D21B38CE3709C6DF295C0C15F14ACDD075C
+ D395DEF85BAFA689CF84096E1F542119629DA031E43A1B6EF06B2E4B191EC09B
+ 48DF825E8D01B7BBD414A8EE16C8019761EFFFB496C0176E704C33F763117971
+ 29AF0990333F362F7CE965105715D15EC32364D76EF0A29A6AACC5F0D0832E47
+ 4058BFE7B232868C7BB44449C3FEEEA753E2F353337E8C7CC00FEE3B12626BA6
+ A28F189D4EA3A5A2657AB26A070E944AF2EF50F013B88EEFB24B66ACAE0A5403
+ 1713B2AF2393EE604EC59CFC13BABE427330963BFCA41BF23E2F0284308D9B18
+ 4815DAFD156893A3C51748C3401AC90D1D64531FA5D63B302B998F56D62FF110
+ F0B4BF2408AB598D81DB5EB79CE303D85B556A4FB1D6BBFF4D5AFF932F178E43
+ 24C0DEB2325DCD9BAD2CB80D7DCCD8B49C0917377E56F34D579BD05947635BA8
+ 9D2B7E0DFB4F43417F29B51ACB05D2C9E489FAE16E8158218156235A591D3D9A
+ 485C930326F3764FCB2910D0A8FCB01052688BBED7F34D6FB5019952E64BFFE2
+ C5153B8FCFB53DDFEE2A42083E4DAF95D52753301CFE3F116A72199E275862ED
+ 0BE6CE346F65076E69CE229CF294738A83629A1874DA5BFEBA24618326B4A825
+ EB3A5202F4415D14FA71F1C3838592E38CD4046212C3214F7C990698E398435C
+ FE2D57BC1B95F459D12FD031ECCEBCC917075FB3BC0765D27038502051EDBB6D
+ 6C65A3E0EE841B670C83E1AED634483D7799959562AE181C6C0FCAD41A4E6CAA
+ A22F0159047D9E8F3508EE2BA021FAE37E78F819678C50424B0477FBE6BAB13C
+ A8FBFC044DEA3807C1BE84DAA0CEA59476BEDB29C5A9944B26957ECB87250DDA
+ 6C5029C1B25E52423986B8702E488E9915DD7A310A56EF2FBB89585E96EF853C
+ 2466D0FDDB0842A825895BEED398E6931C970FEABF368BDAE6AEE0ACB0FEA7C3
+ 57D8F949A489C3DE0FEC2C37C4912802F80EDF30875B23B522360D424F5C8F1B
+ 1FBA4F29214C4376D2842E5BD2AE857663C507E62CE3DFEE0BD1E26A9EB5DCF1
+ 93BCA038AD415B824ED9FAB245129D8D6B40A87C0F146E9D9F59873397ACF0AF
+ B46CBC42FCAAF8D29737A6C8F5BE39081E59955A03F501C1D38A1A3D27417904
+ E80DBCF50DA8EA1327C7A3592A1C980A2BBF51868B29457728414789A38187D4
+ 3D0619773FE35D946130BF3B9AAE4A5A6CE252A8F9456E1742F5531186809AC2
+ 3C1C4C523E2D59C2A22A4DE2224E0C1CFBA502B181A5A94E8F9271FD4BC542E7
+ A277B5C810B722C946B0B1C124AC9B47B04BBAC44E22CAB0463FB86C5D83346E
+ 1B450BAAEFF6E92B2A842A3A2B3443AEA5A9D04FE8B368628D798307C0C85D4C
+ C5D41111625E1C90CAA006A09A34AAB2F967DC7908C328903DB1056C31F9B2CD
+ 66FAB76DD7AE4678D2F5216D01B9F46B150BA513D18AAABA8F0E9F8DA9EA2673
+ 8E587CDB9CBE10BBB34439A099D839D44E1A73CAD016D7F6E029AFE6E3B1876A
+ 991B83E4D8FDE0EDAAB7E5E430EAC3BCCBC0DC952BD5E19161B4DBC63AB01C6B
+ 436D4937B1441F45FD74C0F3FEF37D3CA793282F71ABBA57B84F439D4CA65449
+ 9871196D1C0B08C7CB4E3B843CC592ECE22205742EB7DE2E03020B3CBAEE3459
+ 1A983B29EDF8AF6F7099E7C8BE9F959CD913261B6B24F291F239B188B1F3CE95
+ 376257B23E5CFA527363EBD726BA8BD55F6FA3F435A0B8DAAFA5D30623021876
+ EBD17040246A1B67549AC2B8A79898F741C40EE4B5D4A40620CA49FFEBD0238F
+ D6EF5C52DB47C753A63AB3B304331CAEF855309ED5035E02531D0115C7B62C2B
+ 6C6059CAFCEE6E7F7F61FBCDB8B978BCBA9CF4CD6C62AEA9FAEB10B70F949351
+ 4FC4F0B0AD009D3A25EC9084DD7D5FB3AFAE44D545FCB46A950438D8463037C5
+ 254106583734B29B6072A0A03E8AD87FE514BD71E8D3EC3EF030DADE248FBD06
+ 9A4C9728D8B1FF11A785FDE2270FB427EA1217C8DE0FC4A12E703A3DC9D815C4
+ 3F28B0BEF631F4D1C48F603CE2ED7D2A198B800280F5F0532F689BDCF1F2D07A
+ E749E60187804D5734A0B67144EA88DF06E0E7DA85E7A39CA080D20942A39E88
+ 43D0586FBC08273B82FDE4504399CA6B4045801916E3910147457FA3DAB51A97
+ B1749A966C463568718BA4328D6EF2DD3118C54A17D2354A518F6E2873FD2612
+ 0E815C3329068656FF6818330D1FDECFD76FCB6AA33F79D88C6DFAEE9C9A5B2D
+ 1346B532738D06F48E32FF5E748E9AB94369F9966AEF18412DF1E97F6EBC788C
+ 56155AC129E3145049BA38FE9242BA51E3A3CBEAFF4D0AF16B0EA45BFD7DAFE3
+ E16FE75D07595797239FAB10DFAEDC0EDD1286B442E073E873BE94F64F3BD1CA
+ D5DAB5CBB8B92BF15C486A087D44C574A5CECAFE2A252AF563B5C3DAC63103C7
+ 92466B0EFAAF81EF40EEB534759B3B2D8E03C5D99680CC75F03954690467E51D
+ DA1FF3F92A6CC678F757C8DC5FE43FE59724DC6D284C9047FA06F21DFBEAF1B8
+ D8DB95F2D6B8860C460C4C4C1045ADD207CF5621C4E916A3CC89294DF65A635A
+ 8DBF007D9B25E491E0CD3BAF2AEAC7D3BA971A47B4EB9A72A0B02468D5860BF5
+ 57B4165B3AF3BDB58FB03AEDC250D77D09C49A6E5059616DA62679847285A2F0
+ CF6BC31B4909755735C4352F6C3777099DC8E51B6D8F026AF202CC90687EDD17
+ 49B2DF81C4621DA26D4A1A1399D51A98B510F90D60513C0722A64F5A53913B30
+ 63F89CD31E18656B732E4E81A87E7B1776AB9DDE5E3D0F41D6BA4A0D14B53ADF
+ 0605C8D10149A59936FC84DD8F788F5AC896778011B6667DB23E5E0FE7A46E8A
+ 74039A5EA075A8D679A2EBED420E106BBBE907801C578E225FF772F2C32F9BAF
+ 378D2E3143164A80415B9324822A2594E0EBB6E7F941ECF14CA53CA81EF22013
+ EA12FA3113B7564D7349080D8C08AB8FFE7A80AB9B0C0482C1F73329CCAA0D98
+ 251701C435AC368DBD7232E1DB3FF66172FF935F87312A8554E27B5AFB33DD8C
+ 89564F83FB0E80E912F9A4BDFFDBC6C7E2948B320549D926D156BE9D4C0FF606
+ 6C81CCA96BF936B7B1555067141BA7C3542FA8257334DB13B68F8687CDEF186D
+ 1CD3C390D16203BB88BDC16E61913F7E9C657BC461BEDF9470F9A07029023CA8
+ 95AC63D3A2C01A789AD7BE312B694A9DF8FA0C03B76BF5A7F4683D2B09BE8D59
+ 632E837033819ACBB1BC08D22A4381CEF0F64D7111C701359F58EAA16B9844E7
+ 2CE437A8FD16DB4B8259389C8A62263515579D2E03C6F8038A74DB1511216A2F
+ 332816934709D2F0D3FCF407749C23333FF56B2B133F38BA12A54E4DE6A582F7
+ B479E835A2B0879E67ED586666336F15793EB139AB7C856365D9E9C6B3782B14
+ 42807040D86ED0EF874B4F6A2B1DD8B51A0CE51F64D6EC14A0ACF8B5E9C19089
+ 61D95AB1E9AB0025D127616DFB040721B0660703CE330023B73FB9C3FEA2A79B
+ EA77AC7D64AADBF4DAF5471C401FB527EA5DE65E7D17E3E6E6A511F18D927BD4
+ 308D57E31C166B966F96E1E7251658E5E7B44232935DDF5360AEE367128B47B4
+ 0952E396E973845696D8606F83B57E2FF7737E35F796C113A01D212A19B747A6
+ 5CDA74D2DC1812E70998EC85651A31ECEDA3E467A57C19ED398A95210A9F512C
+ A44A6EF5645025BEC372B0D487832D055855EE819956E72E5C28F92D8EB5C489
+ E5CF82AAB447B71901F451485541847095F352F5FA71BCABCEA5EC3A450913CB
+ 022E72FF60F46BEE6F823DE0FE9343D41AE914BFB0063F854900CA8912690AF8
+ 54AD4CD12B58E0093004362439D392D7C37C5484E82C0E977BBEAC23E7DCFDF5
+ 7DEE36B68C3752A96BAE54BA9C55F0063A5F210FA222B032455996F3B47400CE
+ 14EBD9F5822352B6F1AD96C0C56F13D9C385D313D76BF1E12ED992201BE270B2
+ AC1404D2BA6ED7C6A894FC4161A17680ED64141E5513B567EB60C4F9E6DD0FC3
+ 5DF61A378CFA10B7FA1DA0D66B8D7D34CDA6EE4B0E1F93DF87DB3884EFE74352
+ 6E413FB01D0A6808A56D9211CEB45E8B0D0B6A6B22739842DB70832DD47EBFD7
+ 147F5B5422A8134DB9C2F81DFA16CB9F024CAA22F9093FCC6AA2E4CF2FC20892
+ E3989F2C2649B5C39750E5A39CEEDECC4F07A40DCC8264D0C14C2B2C56F1BC82
+ BEBCC7EEEB966ECB3ED89B61DE3915097CA896774926FDE3C12533536653655C
+ 984503A25E03B3EA7D80628F323757EB9E61F04E021F873D7768FE2174D90159
+ 4D2A7E1224AA6CC6ED48C75E9225462BD9B8F2FFD01E61A798BBD3A7168EE2E3
+ B25BF0F021FD3BAAFF99C138671B916F7E7029964CF8CA090C9E931FF15893FE
+ 00B9928F2439C33F9C481766B901AF4856A9D636835C82C2E8D8220F51062198
+ A9045E1BC71209B9F8094197C3C4D83EEE3DBAC37F66B46E004005062730B974
+ 916A8E7EEF1C5FAA29FAF2020123068A0ABFB3037EAE201E75299A5B2E05DCB4
+ 3D2DC360EA36BF4EE2BDEF45A8778C5185DF89FB3655B4EF502E0ABAD15DD4D7
+ 9A5A62FD42F8CFD34BE03F9BEF09E025AC89BA8D397240F183B05FF2BD7E8B9E
+ 7B1B93DC09C4D1A14CC08213E5E93E064C7EE2948B1EC6230D4C10CD8ADD561F
+ A1E95E3456282A3F2FE7C764D78221BFE50712C577DA522BBF5C1834989A68C4
+ 5E8BE5B14A4AB14B3AC83B0FB495CC32B1B2506D7D42EDAB4B5FEA3E4EEB1617
+ 70C85245C58F1D7F7BBDE5126FB6521441335ED24B9B1AFE51D6DDF8ABB45440
+ 2E8829FE6DD3C16B54DDC5864E63C4F3BA6C4A5C22136DB12D86CE00E553DEC0
+ D8D44270D97FADA93E779699BD0D14F6A26401072C48146319DDA1545DACBDDA
+ 8DCFB205C587710E2D1A9D37959EE7DF9264B5A25D6CF6E318254D3A8AFE0EF3
+ 649A0E28F8F8A7BA3EF0D8AE8D95F770FCC2AC62805CFDB63E36109181E571BD
+ 6A4AC7CD9B84325DF07DC1F14F2693C968F37C18A05C5D1CE629FDD3FAB4F607
+ 3927D61DB9EBEE4CE358F1A364EBC8FED8013D800C658C4DE9FECA2244ABB991
+ 273CE88136280839DAA02F681F014534DF2A8769331242E6C515BBEA78606ABA
+ E2E13BA34AD042B01B4B1DCB2A9102D784DD8146D54C628973F11BDE1B0AA8FE
+ F901675CB28149B85E37ED57593DD4CC5A90E0BC0AF86148633FCCC3DB48824F
+ 3061D1616365CC407E742F4E3117EE0F5951FC27EFD93368E0CDBDEDEA323E5D
+ 28729E6367AD568FD58F9CA5EB5CE4C194178EF820A80365C38AF53DEC79CAA9
+ 831D29473C7EA5A6177DAD21C543604CCBCE37B41F3B4D50FD6E0F45141B5A6C
+ D495B7F05E57A1D4A09BCE923F15356EBFAB39A69FAFF28FD5508FB0ED14A755
+ B2D03A11B1B4262ADC03E987926CA999048F844A29B43629307DF83E6BC5C789
+ 95644158D09B9EF51F39787D3D4A967D0BAC0F06A625F77DB489108AEB67BCDF
+ 5DF2E4BA907C4CE5932161E58561B986B1D02DFDEE3B0D54453E97E9146B043E
+ 0F6162299CB958BC4E5126FF22D99EC1B1B998525DFFD7D69480698CFF22D101
+ B2083F5B8374116754890FA2CC24D8FBBE5C37209B3934EFED75CAAC3C966E17
+ 5F79F76CC8CD5F2C5C7D59BFF44A825DB67CA283D1DD03E2AC51623ACA671B17
+ D535A2DA71F6288DC31FEB29885663EB23CD844AF7FBFB0E0763D1E250FC2D5A
+ DFAAD385B40DD20534187F1FEDE7365C23C32AD34E361139BB664FC16A900461
+ 15957FB58A4B7578543933FA38F4678FAA37502A75BC47A6423656897C6A5DC4
+ C8BE476CB36335C2F5B13CFC5CE9E0BB8A60E1F4754DA28D9CD1FF362A341FCE
+ BBE04B9EEC531F6531E7F0B75F36E82D4D8ACBD7EA4EFAB98B4FA08C8050EEFE
+ 024F20D0AF6AF3244F5F3A801F5493302939486028DE196D0DCBEE1AE69C6B9E
+ A044D9323901ABE2BC08AB60C3B4C6E40AEF3912D4E1FFD6A89D90D9DED2672B
+ E427405E87A0B499D7B9B04AE472D9AABA2FDBDAB49C84019831D9209BF318D4
+ 6258CDBED161D9BEBAC2E481449CCB49541852B79B5387FAE9233692B9869647
+ E441B249989416989EFAD74648783676ACB8303218CBE4B8F4DAC527AD17CB59
+ C7C11E2A07D785458D46403252045BA361914F6705C27A22EF9E1787077184EE
+ 87471DA9F774AF16C9500706C1E5DA7AC94849ED3389A14D3686581D07A30283
+ 6E18228917144127B12DDBE5449BA8A9785ECB5AF6D50A5010FB6B8B277F6ED2
+ 40FED508FC0AA948CF6EDB008E11B1F5B1014DD8E5181364E5B531C23061E25D
+ 7EE98423C1D018C719B2A3A3212E441850443C1FB07F76F88181BF972CEBA8AC
+ EB52A17BE6B99F306E8781805208D9E336BCE524BD25CDB3FA6027EE029846E0
+ A0F3CFD1E436ED42606C80186EBC9B30BBCCCC83871FF30E8FA6C94A4C69D919
+ A6D539C3FCC33A97EB734B367ECE4B6648696FDA3006ADB60D617D31A5B1879A
+ 5324B30C8B5D6D77799705CE160ADB5C20F052D802677D0927F14FDF9EA91414
+ 43943D59EAB7BED23CA60FCF84970F0F77AF974CBC2ADDDF2304AFC4CC71B117
+ 1A24BA7C48EBADB9CA10213C874C7B95801830FBBEAAC445CC5724B5BE64D90E
+ 754FF44F034AC9251B05CBF010878667DC8BAB28A576C56FD046F9D9BEDEABCA
+ 8C3C9A8961B92A6D2D4056F4A9CC39299B4C21CCD1427316D35F126911F24DE9
+ 010F048615D959B17FD3831479C18A5FB1F10CCB84237D02534A10FF716DDA09
+ 6F8FEE288098ACAD2D2461CB1D93C137AD08538FBC47662F120BD29907389C7B
+ 990D2D76E39D55364C6DF659F7450EBE1F64FE11813FA8477ECE11BB02E7ECE2
+ 5C869F9E722441BAF4C703F7FF5E3211B5E11AC4FDB023A8AB08AF7FA9830037
+ 70060858C7F47B5B7785BD839B77288C88551CA77F26A43DC5DC57ED6C53BB33
+ CBEF456E4E80011CE5E465FB8C6DD14BA18221610A07F950AA46CF79DABB832A
+ C760B2AEB45B474009ADCE0B315AE5B87B4BD762D1D88F68A0F92BB51CF144BC
+ 31D459AB1DD3091721C85A8415EF118BD2EDF0F2AC4EACC24080CC2F6609F072
+ DF5E71AD0FD39F62A4A0BEEE239A9DA30F6E7249459329A57F6805F1D4DB86AF
+ E68DE485A08EFFD9F6D3C34ED339B7F56D40067BAD60A6A3176C4D68AF44C010
+ AF3AFC87C7D8BDE4F451BD1F801B79ED94BB32D81FAF8A92411FD1D119D780E3
+ FB848D98BD2AC749B4DF7F8736BEE8079C557C75922E35262804DBFCE149B975
+ 6CBF9EF1586513113896FD750B0FCF7BFC3E59C05C7676AA277530428BAD0EA5
+ FCCE202DD9DB8789A31C01A9881AD22F17AF0F366A11A6D692ACF8F4F4690CAF
+ AC0E0FC371FE078E9D3D3346511B8360410979C9C24A80C9E0869384E385990B
+ 5064EC2591D6EC571A2D13F326A783A34ACE17D7961BF70B8CC008CB13703E8F
+ 73AD36A0B9F4C0D1499ED431099BA14D8A445B6212B2614BC780746DABDACD38
+ 06B3B4833CFB0F9A13C0F0D5880D36D875C0BB67F8CBA206C85CFB472F4A45C3
+ F1C8C6D6FE579F88969B57EEFD0C3F12357B6FDBD7ED47E71CC4E71CEAFCEAAB
+ 86B9AEF273AA33B27704294B4AD120D1BDD45F855037415EA3A0747EB26B53BB
+ 4434F7BF4DF11D40D59463CC1AD86413F38667D047AA3C2626EF91BC7E15D997
+ C7524F2AD8972CA9917177DE876CAFD9EBA38A368D1D5BA79EEB2703E67C4BD0
+ E4155A53F92D7C0AF3A1FC8B7A125B9A15A867793D20F294C9D1867DE536C364
+ 268F16B6CABD3EE553EB696391CCD18113D9324CA438D44659F202B6B1BFC677
+ 2CFAA1A4F4225B5AB9057290F4B7476027B61348F2B8FBB3D062D02C69E45E5F
+ B167BE2B8860F692360475766D6EEA942F0694E137BC42B8B99072CE80EE6B2C
+ 2AF0DD9458FF851792B7EE1DC99EC2A500544C38A48D4B61AE64A7554E493588
+ AC4A05DB05D37FEEFD0E146124D4813294E197402A108EEBA67AFA7E0022D5DA
+ C6AB25092BB584AF1FB1202BC1978A89410CE78C5399860581584A8812FC2677
+ C3CBBBEAFB7CE631B3D5BE294A9EFF7A8C9A6300D0A1BF938A19464E7FAE1076
+ 0F47DE0F1F01B8123421BFB67CBE7600239E983556A4E807588AB5935E650ED6
+ B2A08C8669A774AB693450F8687DA06CBD7B5A9C16178B2D72BC90307C156D9B
+ 6867A1C0CEA433D91EA67B7CD301710D6FEFC9128D035BD99D156885B4405C77
+ 5ACAFBA174D17178CA55A7EDC883DC379776905A49ADDC737C2FD0102A774237
+ 1C0B8957106791A926C8B32971FE4BA9DA0984F83D4E8887A9DCBAA33B9E9FD4
+ 40D7BA5D25C42E94886D387B34941F48468FB52E2FF48E07D2BCE63CE25D13E3
+ 14EF96995198B3D88B906E9D0209B13504ED2F4AFB3E9D226511B5B2D5C800C8
+ F041A8EDBFBA891F58EC9B477C7689C75C03EAC1AA1862F923D3B874B1521925
+ AF0ECB34E9A41DFDC33613A1B2BADD639DA3536A7AA17C677C0038BB7021464D
+ B6E336569DC894A5794BAC9439910E5947AF74C7D68F5D80AF57E62BECCAAE66
+ 7CC7296AB32295D18C734D306EDCA298A5F0B34917FED423E8701D6CCF5F0F43
+ BDFEEEC361A020E69A08EBD3F974C4075D49BB55D0AC2F223EED87F1EC7D8665
+ A77CF3C9B6D8DD5E048CE0044ABC743521944C881E73818EB0EDB2A74A3CCCD3
+ A26A455DCC428AFF629E7F85ACCD8B0DDD54DB3D3CF62945511A7F9C6B573CA5
+ 27BF465B592FE080CFD78B369843031A52178A6CDE7AE610761F1D2944EE995D
+ FFAC35489196D1E33A272334C771EF05B05A78B0FFBD9A6FF9DAE6076D88E3D9
+ 440031556DAE480A252DE4AD9E56410DC21FE5D3E39C44079E7954E05AF2266A
+ 171FA1BC55DCE9FD884EE78FE57DC7776E85FAB87DBBD81C122DEC3C1EC8A059
+ 4729E87CB3084E1CEF2C22560AD5278B65C1A3FF6E2B329D2EB53BAFA7D8E388
+ 3B90D510E817A30862118582AAA8D6D7949B823FDB1D76516CBDE2495985C8DC
+ 9BE8E02E373C3026EB88766FDE204EB5FA131A10B471C781554368E2EADE9123
+ 88E015753BDE4F7C008105B56EFA9746ECCED7206961E9928A10DB892DC59671
+ 9AABFC9B5B8392DF0CD2A76B58A408FF2FE710706A96E89F38475DD504DEB4F6
+ F8F22914C6A7B8446E238868950E457BEDEDE362D508E189123DF6CE06B10E79
+ 3981036F4C25377CB8422F5F562A266C36F1FF7C2A83875AFCA80DB84FDB75AD
+ 6CB4FBB115340DE0CBFB8BD2CAE2E0145FD0AF15EE4B5BE4EEFDF5EA54A530FB
+ 23A8EDE7E8B3FC87EC0744DB13ECC3C6C72DF093222B0A2663529B9FDCE5CAF4
+ 8D3CA53B20AF503B3141624D37497D2D1B951A5723B3AFEF1DBFA2E3D51CE089
+ EB4F0F900F6BDE529B30535A0425C24D8051AE5DF4C7DA3D835CA64B2F0C091D
+ 3DE80052998F9A72FEAB5D266FEC617FE4610A6814AC38D85BFE2F2F07393C47
+ 0A9F1307E68BB42FEBF539644437C999117CA4F34CCCC1DC27F5CC36E873BEE9
+ 591C38294865FCC2C99B560159A8C3FEA715CF9122D8C06D8725AB5E6BBC4502
+ 5B15DF5D3D5EF86E77036B435F0B40AD3E0090C76529B77B9C08870FF1BC306E
+ 8F452FA36D55B69B1188908D49C00DFCC133897566FBEC9C8AB64C221965815A
+ 814EE40EA254729DF39998E55C7045CF483CCA1B0A18203B0F759DBDDF3B06E3
+ 012F1D6B7127C0E7D1B06192679AB84F298733E11DF64ADCD59C8D23E5B4A369
+ 074CC2D39C85478099FFC2AFE112BB4EAAC67884A6CF5AF28A114456273AB557
+ 80AE608C4D5E2E234B174DF8D0D63AC774ECB395C3844D3E507BB443FB40C49E
+ 0A8DAA93A568E2A5B02AEE1BB1C525B7EC9AE43838B45EFB6F0A9D27728B117F
+ DFC1918C80E93EF1E3B82139CC02FAD20C088A45DAC89A6520DEDCEE5ADA2EE3
+ A67CCDED740F16F0BD593C998F2610821B6281492E2868A834352F3390948FAD
+ B19894DB79B24C85F4DC03B8EA3C21C90DC1DD5412573997719532B086D60364
+ C1BBCD154CB887FB8CEA7F2ADCED96033205717BC98A41A845D4593E469B9112
+ 574B718FF234A6D7F27AB6E04583A5AC8722FBBFAC683C13617837264714C420
+ 29DD3700FC0796975345D13B1944D61C7F0A13C92CF2D868A7EDC93E37DF5486
+ D74C36BF955F105CDCFBEB6BF2D814207A308D1A46E01916C859A1F8FF00FB2C
+ 9C3AA69126ABB16618B348AF6A07A5F7A9A5F01B32E19A31F3615FBE37B85AC4
+ BBE0D8EF7BAC72C68FE2D7A22DC73F81D1B482A065AF4486499E526478C3BC27
+ EFEA355DC48604D7E995928485FEEF674E28FBCAECA0E3CB60590F3BBF627C6C
+ D0C074711115648E243068B902A409D86F4A2F5721D670AE1ACEC1F10E496C05
+ BCD73D2832F66DA5EB2EBADBB16EE247217020221FB3C268CFEF2A6D333B94BF
+ 3DF710B51D20714EBB11219B3576236DAAC075F5C49CCC8534DFE96E44FD66B1
+ A662766C25021C5DEE46EA2A194938E82DC3F6FBA2928DF753BF9FCA99A8CF45
+ A94AA622BE200A9B0F06C7C939F5A40FCDBC8D7D37F2A3ADD054B01CAEA3AA84
+ 075EC03A4DD9BBE2A79D5A56DE5F3767BCDC1CFC1DF13A063B6E22330562E793
+ 926E250D2B7A61DC94198BE389F24A65A83DEC80A064E4582F548B8DB7AD80EF
+ FDAE49802796E9306E2ADE8B76BFBC53CA02F20F07EF4406BB633337B69175E3
+ 694532B0A3374F27689273322ED1C4D9FDEB2CD4E253C6FA97F71BEEE7F4519E
+ 1ACAABD5C5403AE4427864DE10E06680FF99CDE6BD3AC607CB03C9469D1114D7
+ 016BA12F525ACF2DAAE2E74A4460FF371F7C71701846EA0C907EBE938D9142BE
+ 351856BE83EFC2C5D0BFB25F9316CD1C3DE499D4C20ACF996275BDFF1BCA0CEF
+ 42AE136DB3E1C82AB88F308FF2EA0F00E8AFB8BAB77E85B4BBB302DD11F2476E
+ 29FE12863BCB1B6F9DDBBE973A7BB27A6E153E4342ED845262A662EBB07CF75D
+ F8737D00C1DB415452CB6AA37F12DDF9D7640743F2641A9A484362ADE24C7630
+ D15F7B82A5DEA9CF2054050D38BDB485A2B3A169E2881B7F65E4182C0F374817
+ AB4D31C88B07AA0641CF7B69CB31295CBB208910481C91D54D5154C4C2B7520B
+ 188CA5ACC176A006637B829D82D59CAD0D9BB17811B70F24E593A74C9334227B
+ 3B0807BFF76D3A992C76625F93DAFD421A5D36F4A9E0EA93208E4E1A5FC73DB5
+ 1519843DEA5CCF2AA04BC3D4519ED07235C1C6478B099D8848288336DDC2C0F6
+ 71E659EA519C086170D618A9CA6D24FFBD4BCA4E99DF86AF57D622CE6FC8C35A
+ 71C7E3EA43ABF8393B6250EEBF6212B5BF3E08DFBC8B984020F6DAA6E62369A3
+ B4FF2684F9564A65DBDCB688919AC3C285D0A7D796EC1DC56AAF7C75CF67B95A
+ 993F64E3D4A538EECE714DD5B7948413974B062BCDE2B2FB8C682C7A44516EBA
+ 917CBE51DB19364C7784208254CBF20016BA6F4C2E63B9014468FD387F672CBE
+ 9E1CB49465B46021169C7E513C02CCBD6B8C939A093ABDC3A819A95D6BBDA0C8
+ 28D20097A15FE58462254E47D1FE4D736FA77EE36EF5F2E7154047075E0403D7
+ D0C324254FE26BD7D808FAEBFB875D55D8CE1ADAA1D0E6956DE53D30C06B8B90
+ 50B4C3E9147AD723E9333A06E21385ED66A3DFB497FD36DA3AA3B74642E8D5D0
+ C50B42C5FA4DD53C8452B29921923E138309CD2E5AA9C87021F3BBA6F998EF8A
+ 1DFECDD8A6E59B237A40277DCB58C8447A2DF444786709B5F00BA929A6A6840D
+ 1EE6F6F487A928E731136EB9CEA061FFCCCCC8B549610EB5B3D2EFDC6CD90E88
+ 8824ECE1F445C15A2C1DAA39E691C7F99E71608C3A6946AD4501389B5EDD0F8E
+ AEAD70A468C8BFE40E62CFC160DB276943C6F3E08136BC711B8EF2DAE9139A8D
+ C8700054FAC4E067559C6F4FF1F2FE2785B0458E259BF99729B21C48FFE3F8A0
+ 1BBC3C113976327AA1D40DC665620427E167220284C3147B65EEBC9ED167CEEC
+ A813EFF24F8F5332DEAF0E0170ECDE2DDE7154EF4E48E1C5DE9C0990F23B2419
+ 11A1A716F92C574559976B790A3CAD328E1A433915E0CFC8586C94B47EB0664A
+ 37349CC8462AE9D75EECE95D7066D838A951C8A0E20920A4B53078849AF434F6
+ 2E06FD8AA01BCF9C119001B3F46AA73657D08E388CD06B2F1ACF8E88F7FE4C8E
+ A814BE55C41C1C8FD3D48BD6107C171741ABEDB88B1E1BC5CD4CEFE317C13729
+ 35802C886A31C193D11DA0DC3815D06872E5FF0A6898CC60574DE2920AD80864
+ 4776438717670431178BC7E08403022CE11ACEDCEA5653F48E2FC86E730443FC
+ FBB468CAA5CAF32DADBC8D19B6B11DF9C40B38630EF18035A141FB432EA20FD7
+ F9E4F61127423E976B1AC8E27E323A3C4D11B3258602E6E9E821C0EB88AD36A4
+ 86DD5C2F9A5C1ACEE02EA86A5B5943F0D999C56AE54D041AB7A3F91E0262596B
+ CA6568BE184C38F1B144A7524897D118DD0CF247D2E62F7D7D8BF87A9FF1404D
+ F2A5AC21B9F5B76E1BC19766674E313F6259C6BFF12CF4B9CA67E38D77979B89
+ 2151D79A2D55458735CF2200E0A6055457D7E011A355D4CC0C3AF7DE6A1CE337
+ 85CE03F8E9A3BC99B59C7CAB90C9FAF853F8EF18230B16BE30C2184C36DDBF0B
+ EDB68CD06C1368FE63D0B18A4A64185FF9F7D68668B597EB6BF62043125CEE7F
+ 8015DDB933C838D28DC6CB84032753C1EA6A26975560438222270E8EA890009C
+ 31FB289F18F96EC381ED0D224D511C15704C83ECF6883DB2A84D16D42BD98911
+ 7D3694431402006C8D4063D562185BAAA399AB0F7178BDF88653695DE9068676
+ 4C3EED8B9B1B5FA7C898E8688337C01B9E101B10CC0879430F7F49530A8CB3DB
+ 1A038A259B1947B4107BD35C4270D5F8A4F1863D00183D82AE78831A6922FD52
+ C12004A72DBF0EC6FB493CA5BDD939DE7C2620335006D44D45963AF5122AB255
+ 45F2D1B1AAB5EDE8F25A629FA7F31E9212E1594D82F19D2DDD3AE062C0EB33A1
+ 0899FADEED59F623025EE344D4B07765919015690D8F23D60E6F2343BC8639B5
+ 759CD98B4147A7A9CFC0752B738FAE7D4EDBB214FE82B485936E07F2CC9A90E9
+ FD5C6A457A46856CDA77832064E8A3D9221A175A7C2AF71FEC4DB2E4D820053C
+ C18AFDE5CA096769C0FB83D13E39503854C64E83405C63550C5B83E90E0DF3A6
+ 328B13E2EB29C82AA6D8D852B01FF6F47357B909CF2AC30D1D312734BD220D56
+ F55E4547A1D70825AAA737086C51F088E11B4216E2FE26E7D5C9AC9F5A315554
+ 6DABBFEFBF402EA810C0191B3671EA27ED2454284B253372B3786C5D976A3264
+ EBE9A814E2AB97F4E818236D07F253A14F46B03A6C7FFAEFD120B56F7A9607A7
+ B578B9D49E574D2AD02FBB36EA5D0EE0DE931D095D037DCFDCD2A73CE86661A2
+ FEF602EEDD487F8AF71859F8F37F8BBC4EA1B76D70461E219055E0B0B72F129B
+ 3B2C86F2EE502F2EF2A90C3A1EF0720DE41F5906708D9838FB9EB830CE27E20D
+ 25B50A0ED1D904C7F9103E6676B2D7E6B327C5B9C4685ACF7EB3106927A97A50
+ 9F664B3B1C58925AC03D01D6B187CE3E9816299E3EFE330437A88A9C58C7DCE7
+ 787A986C1EEA86156FCBEB3D3A2F3F1AC8381BD921BC973823D175C1B0DAB71F
+ BF2AF97BA4EE89B63614D7822D6F95E37DAB190CE3DB6BF8A865FEC0C95CB00B
+ 401DED3C7F18B72707DF69190DFE03F1B5AF071B00871CE779888984D3C0D8FF
+ A9890EAEC7BC7CE90A07BFFCCFC94F8660570C5C1932F176B35F2A4698DE9A4C
+ 7C1469D025056850AFA9C685DC1EF39179D4C060FF71192ADF35560B2408F453
+ 7FC1CC1A9130A89B0188D8C1DADFA6D491A1FA019D2A8C20BC6BAEF5A7AC2683
+ 4B6D84567E0AC8E99FA32E0E74A3C680E0C0E65AADE0BF8BCC44C1B5F477F5A9
+ 4D9A702A4B337AD188A6B48EF95020C1D3197C866B23C364F028F257F73A83D0
+ 3DED84D3EDE70C6B5197B0AE69750818812912AF1911108FF5F1C0664F230A11
+ FC6735DE3CB3262CD9DF62D4DF6DFB50AB1D996DC429CBE2DE52C5FB789D4908
+ A86814CB816D653C142B977C19099EB38E8B44129FF768FD2176C26AECCD6130
+ 5DEE9938B178E9EA85F8974224CB47B8E694379748A63D4C73003B2B3B987998
+ F11BAAEB4ADA13B5C617EE269C2A6B154E9DE89A8F188C16311417507656E5E4
+ D46C8F6E3CED557C8F999CE3FFF5BBD206B19E2E3DC13AAC846291BBA5FC9336
+ 542AB1B3CEF2C17BC27A60B77E61DD614D880D2F18E3D73620E6911C9E60681A
+ ADAE60DAA24A286F1D31004EBF4C92E7EFD950149830B65B3642D87800AEBFDC
+ 5560609739B9C0EF017BC8F1CE611A468105F227FB23AF8C66FB0BB73D1926CE
+ C91F048D39A4977AF2B2F0651F7676B2CCC8CAEE08D772FB2C129BCEBEF40AFA
+ A15ACAB83354FAB5BFA8E9460204C9CDF5CE28134B2EDB87D4D28646881A1A83
+ E3626A7C15723EC3388CDDA9F904F680229A6DFBB98E60E8C0203FCA0FFEA6C5
+ 572D0460F0A7BEE5B9F808463FD7B53E67C1039196D3ACF887E92205FF3388A0
+ 46EE828D5886A342CE515044E5954036684CBBC2749EE76F48C7D7ED49832762
+ A5631966C5B3833120795F6DB54B494698F5498600946E6594CFAE231FF00269
+ 4FFB36A057EE5862E3514462E710ACC81E851E11B437A4B088CFF726119ED3C5
+ BBE6E6095A1CBE123373BA609CB32AC1099C5A11A04A9B8128BA87C73C9790D3
+ D1091FCAC9E75E5C3455F095F614F659B7D4230DC27D411E6444FC2912A2591A
+ CC4D1BBA67E1B8BE08AE41BE05368212B77B8D9F5143C54CDE0578922503DBA4
+ B3123A4C662A0672B3FA768B34D6410B1DFAE923ACAE13381D6D2461E1E8FB6B
+ BF720C42DD1B15008451D697DAFC3A06D29F2388FD9C50A1BC2C5DCCF493B36B
+ F979D42DC44FB91C9FA399696E931A649456EC9E5E883ED292F0A73AC26D9AA0
+ BBCB6447FBFBFD29CE092AE27E783C069A564531EC3BD871205F751EF862BAA1
+ F05D965C928DE9385690E74F9D64AEF8657C941C595CC103BBD4C0427CB8E4D5
+ 1F89613DA5E39C9DD65CDC245F116A27313AE27CC28F689E1EA83B0B0D1BD7BB
+ 2CDC82F9BCA277E8E88E9966781B69F407CE51667E050E1174C24B0EEC23FA23
+ 64911CD93DACA1104AF0C204BA24A12D0BC0A2F9CF407F8DCF9ACB7B97808BCB
+ 57C590DE4437E585EA1C4AEF506B53876C66DBED4052CA4FC34F1276488EFF4A
+ 5C0BA4288B486118A12BE2B336504A7CA3BF9EF00D8BB311C14669D63916FAF8
+ 640E16246B00FB874B173388B4F35D4024037249FA43EA127D6FB1289FDB1DC4
+ 35EB991A947CC04A8184302C9D26BDAD8338286B9E6C25F8FB28E56FD2FF9264
+ 3B603BF70808A33D32EAAF6BD9B7D3D1BB0DF4ED309C4EDC0680E20E2EB257A1
+ C38BE5B8A403776065099EEA90657409F81EE4BC6C8E62D158CD0D410A8E79DF
+ 1526F4838FCA8C3BE0536C0D534FE61195F683BC8CA14856E4F5F576C9AE9943
+ CE59F445F5206178F510B07C88051794063B7D0CE621D8991112597556CF0B10
+ CC5DA7615B16D794E01897FB2C29231F9F1ED14BF36FF3B800DDA7F04D3846F6
+ C2012A10E5408051333766C19FE9E17CF49463CD8490C098CAFD5C64F31B4B5C
+ 33907857DD955C999B01F63D41E0025C1CA3DBA71057304D5F00F13E339AE81F
+ A85270EECC1F56BA09C3F06F0E4FFE8E04EBBE843635824EAA8A234F179235AC
+ 4A0BC0FED9734E1859B2B7A0D649D0D1EDA1042407DEB68B5533234966981C6B
+ 21BB4E48BBAFD8F1DED2CBDAF6F88F8BD1A12D7F0F726A494737E8B45CC730A8
+ 348F89AC5B2AD0BE60BE023CF03634E7E62E2C2C770CC93191D46C73BE8EF844
+ 112966C27D0C7B7553E94F287D68A78A086B33F9017DB7C52209D1AE28CC7652
+ 261C8A766BC883A10E6AA03993C4B0024080F996F1363CF0FC62EB2727C43D29
+ 96DD1EBD9668958100BD3E04151A5F19A53E929FC412EF096A1BB3045121F2FD
+ 6E5BB3B09F9577C73E6CB45F6CB010829E0EFB6313D45DDCD435169C5BDD39DD
+ 828771825856DECA8EFBAC2594AF32F5EA75A9A3AD6E7D763E04E848AFB872AA
+ 93429CFC187C38A37F8753B185FB17110170F1D3CE1C7E44AF25ADDBDE6F5930
+ 5B0BEB1ACF9DA566D814FBE9D73683AA9BC3EF00C11EF2D13FEAD7A3B6654961
+ AD644444C87B0853D2FC652707364011AAA132A1AEAA1C0CDA1B49DA906647C9
+ 9D70D62906E4AEA736E1373878D5EE08245B2191731B1782B091661518EE16B0
+ 9342908BEF11A7B47AA3818329E3CCB69C8AB144B9384DD7A3CFED5C965DE374
+ C663F2B5A089BCB4AB22CCAABBB4025EE4DBF759476731ADA93D12A79105E525
+ 3C7ECCAC78BB75154A1A92E1026CDCBA7D8E5ECA65E872892A31EB1ABA8B5490
+ 0E29D0A91363CEB36C4743BD844CDAAFA6E144E930BB522D4453426C37426621
+ 134808F3FFFDF13C10EB662105C84C7CB8D1F6CA2262C77A67AA934B347330F0
+ 607AE1FDB1560F21A1F090AE6FFA89BDF5CEB040FBA884075BD99A2AA71FC265
+ 37613DEED860E848057891F1EC05B2ADB568DFECA5F19D3AEF3AA7A4745F9CC0
+ 3BCC06BD824CCAE18FE47885D2EF8A8B64CF97F6E9221B2D7CC19248F32691F7
+ CF9E59E7116B9606A59DE15228614AF32239A036269B16D2D935976D5B5F1E79
+ 8E4C02386340D38B8C090C45443DC61A4F1EA5E44C9998899EF8D1D72CD34589
+ 9E0B6A9EEDB414FDBA5C7FB4DD5339F009090BDC89934A0F8B3BA270E9CFE028
+ 259FCF18EF86E9F1C4DAC99FAE9ED0A9A237F37DC55206A817B099F5721963CA
+ 579782AE69D8673679D4FE0969CEE5872C785AEF727B13D640F6ABB8FB276A41
+ 858C41815FFEA92E754C356D1CE5EDD3CC801A48EC6B881DA0C4C283237DB7D5
+ EA5203088860EC808A5A3ADA0A00FBC7675DED35BEDA1B1F0960EA4A5A31533E
+ F6575BF137BBF2A60D08BCAEFEAB594BFA8E16EAE5A1FA8DA1223DBF94C6ADBB
+ 695921AE4F77D44B951266AC4BB2261630C329AE85FCCE1F8E8E8054BB3A6775
+ E966E3A84C273CFAE9B993685B86AB99410D32EFFD7A20740CFFC0C220756826
+ 85888A16950565FED78B87CFDF2300F3E2CE54BAD21DE21B7D57A6F602C0E839
+ 3EABCD9A84FB44742B4D3AFDADD3A5CEE7686512B8CBCE3594B407A0668DF49C
+ 03D7523571CAAFA58DD723F1819DDE6AE9369FAE5DBCB942069077C5B98449EB
+ 14C5EE522CA07B3649532DD16785ED59C2828C7E9827EBC1468EF69541279AB1
+ AEC93BDAE45264FC8947BB288F3604A2497B0C124147C6CDFEAD96749061C0F5
+ 7341676D323E95C83B63FC4DC5E1B311DAFFD3D37946C2C0E374850D2E1B02BA
+ 563B3D928C517813A2C62137674C888C2AE3C8D6A3DB07BB42084BD493ED821D
+ C732779749B1AC7921F08597BDA062EA6D1A0E9FFD1836E3C0B8B81497F79ADD
+ 4D2BC353B740A4FE35864B31EFF78D5A60A4C9BA3AAA8335E2350C1491287ED9
+ 0BF2394FF053A564472D12ECCCF823037E46B17A5583D882F3B0EED311337650
+ ACEBA8EBA5D42D041F35B3E1E84038C6957911A0925AF75800E4577711183B33
+ 7C9C8C26CE5DC05E0F2BE585A0B1423503265F3DFB1D1E4A34999AC683A04B6F
+ 76173ACF52E0B6AEF3C489A4BE750C59399707A25A510043CDBB95F3CD74FF12
+ 3152F1516AE3FD8744A4F2D85894CF4AE7DB3E00C10FAF6D14DD6B63C1445C93
+ 74565976746165076FBDD8D1C776997F874B0DF13B8EF4CFC8D78A5E5C7D07DC
+ 288548EFE6A1350A860877CF807248EB5BDF6193F0C56376C3BCE9D016FC6E15
+ C89E4700FA9657BFDA49ADFBD1A342A158404C64197FFAC3BCA22A878BFD58DD
+ E3F8174C12B26CC691B1902E3698728238A64EF532210D07F86315DE3AE7B5BD
+ D8EE66E1D018689BF1728BE839FF99E9B036F15E4E9194393FD51E44959A92B9
+ 4ACDA4B62BC89327034B9F56185E31571EB5E9C6BE0DACBE3FDB4E9AC75AC8AA
+ CC9273AE4EC698DFCC3B94A4F731942F7E699AC8A258C2C0E78D49651A4B5716
+ 9253F747342D6D743571544D8DFD8F5BC68E89596BF922DE207BEB62EE8A24A4
+ 1AA696E3FE720252186F859170BD91522CA17B474CE826004CA02CE505E87A7B
+ 94D80C3B47EFC4D0B96C49DDAB8EBCC153CDF9C63AD609CC25C26B6B21E01EB6
+ A8CD4A7D6F4D21C33C5381E36871CE61D3E0B8A97B11D70342E9B66FBD93F3DF
+ 071015AD30376504D8058683757368625D975AF2F010A0E98A2B14801A51D467
+ 67D291D8355099056DA0B7124C46E6E27D4A9D9111425BE63F4F04250450B710
+ 7AA0A9A6E2E114C12450886E568579F479BDE4F5E1E5B2A95238BB60081B7FA6
+ 0C90226B18B510050159EDF7A15A5A97BCAEAE6053FB52C2FA918181965F213F
+ 30F3F8D208BBA786BFF8602A8F00B6588ABEFE3DA149FCDECE87A2944B211193
+ 3779D87903B1FBBD01A4CD05B90B24CC9956452EC7B5696EA11FCA946C6E22F7
+ F62E56702DAAC6627DF70926A8B31905172F9AAEC20D4932D730256DEB6A3B16
+ 12196D7F08EBCB845D0D756A9690DC0EFB00F2CB416AFEC3C250FCD2D7D6D243
+ EED82B72DDF426EB69CC170BC7263712AB867D57351D7D1397C389C23C034681
+ FE82AA5F482C7940F255099239BB4E188F1ADA86E6C3A8E3C6D273751518BDC3
+ 8ECADD6ECA58BA6FCA22DFAAC1CAE06C65C2C961334986A0E564118796E51CD7
+ 9A021BC80007780B683C2DCDDA394F57C2E8ED48847516F8A820B70ED6122FF6
+ 2D98A3E2DDD7B48506ABD4376A7C54DFC0A00A248F24010ED8F4329F13BF8C43
+ 6B717264C5416B6319F477AC3B7A8088949CF72133B3C3A94EBF17BD9D518351
+ FE6759132CA177BFC8156DAE05BAEAA2AD18FB08EE9A8EEB4CA5869AAA1F7EA0
+ D2511AD8F11C0E22571507E326C35F74B5F2A009B780D3B443C17F0112D6B772
+ 3B340E4F607FD9759598F68DC735F93354D86B07E23D191AAC5C4BF219F52A67
+ 9873CF5512C324061DBF603850649E44EA68F1577678E50A3B720912E6B0B9FD
+ 860B3B51EA94E1FCE02E2A98FF143C01E0F5372D32B14927D0324CA7328D4393
+ 00A2C7F3A3B098572ABD1410AB5B0960F64A46133259F80314A6679EB02A841C
+ 238A5613EB1861D5CC646A6CF1B4D373846DB693B52B936D75786D57A9ED5198
+ 0A05C41AAABDE4099A8F0776B2B88CB2D7434F47FCD538342D76E55679967491
+ 440A6950309C5AAF7F7D46D2933F4EF2416910CF5407607ADCC32FB5CA572172
+ CFE1E0E5CDE9682563C17BFDDAA28639FCACD5F6487FF55011DDA0A42B19DF36
+ 49A23CCE0DFF04C9FA028E2758A3A37DBCC567AAAEB0BD4CF6B68EFB0EA463D8
+ 41659DE3EA58179B41DC43F9C41DAD411B70B7885AA592DCD5C3277DFDB4A58E
+ FA47DEDD677BF1035E98F721A88998E41EC3ECA422556EC72D93EE1191B2E170
+ 195C81127837F7ED06E90DC9704E3A337B697087C46578C1C64F2DBEDE29B808
+ 6ADB5BAA7728844297AADD1E6D5294CE903093BA3F52B2DA329419B300366C44
+ 44CCA7F6A1D070BA3F84833815A177CFA10038E3BBA3F8F2091B9A384202C61A
+ 5DF5255BCDF89996E294B369484DFEDF58060574F43C43D3A917197D067D7900
+ 8A0F31B20558D626CE2D9C78D07D56E731AC062E43011DA5B6D643B168B31209
+ 75008552AA89E61A859ABD7E5D09FBB691968F899B175AF8F80B7C5A73F2E5D8
+ 5FE5417D20876C474D9711C7365ADF8D294C940513C386C67BD3D364ABB5CE1D
+ A096D2A0813212363155D08DE7433D9D287E2F100CDAF0466E5376E93F4D55B3
+ 5D7C9807AA0CDF27EA973E6B9CDD423FC078FF566EC4E2C1F906C48F46D35809
+ 6E139CB9545B4AB9C8F9E7566D2F4D55B5BA5CF65D1909D0E5133B7EE1489FC7
+ F1290E9959A91E85A1EB2A2E7966FDB2BBE2536F7D429ED9E64FC5415F458353
+ 29E0D01E4D58A55846FBE4FEA1CC70DCB32C4D57B9390E4C7E1F7DB27C41BDDD
+ CB6FA105E57A8DEF347DB44CAFBDC23FD5735E34A681E7153E769C20310405B6
+ 7DA5C42145ADE57A8AD81BF14BA766DB5884986230F19E3CE52EAF1AFE281A40
+ D75CF07180CDD1EDB28192CFF94EC12B897206A4FD077DA5CC894B7C9E0D20AE
+ CB44CA027DF70BED52AE8AFDBA2BDAB12FA081C0A26490ED2DA4EF01B123E00E
+ 358B46B93E69403E8DF2F0C5EFEBA6E2057027AC159B95BEE2C23BA75C6ABCA8
+ 7F71E1B4AD0E4661D47CD4D25093220861B3F8D8FA67E1E778B589C85551D6D3
+ D3FFF6095AA8A61B3C282103E83BD33711B2FB8E3730180DC2B7DF4432DE1D14
+ 97CA9B4F1C03BFA458256BF10D97A9E439923A1C83CCFF6300EAB6B4AE6E0F7F
+ F1980BCA79C29322276677226EE8F0CBFFB6CD366241D67DC86075E5CEEEE14D
+ A962E00A62A4E317ED11740292557611D34A40198E2F9429903F4D8F06B5654C
+ C091CEC7C7065FC5DCB175C81A365C53F361DDF184202BC1C5C4A8F90B6A5B73
+ 0B04D6695A3385ECC5436C9AADA5D9193B6AE5C4BF5D2CF42475F6C49EE9DF44
+ 506BB18830F7BFD628FF3D9A9E35DB9098C7571DA6843FAE11B862B3A483AD60
+ F528865DD123916FD31A343A00FA9ABCBB7B19E537097AA25300FD59F5771387
+ 5B329E0CD3A4A3B192B310285611306438A74570565BD450AA0AD68E5634BEB2
+ EB9D7D28E272810F2F4BE6E109E42F8A2E94AC09ADF852B70623FBE7696A73FB
+ 7354E12BFB75345080302F54394471E7F3422440CAC1069725E386B03912F452
+ F9F34083FC93A856EE1E19BAFDC86385D2232BEE1FB17240421A2FBD3FEAA2FF
+ E1179E443C18D2C26DB04B6B4AF1D2DBA0744B87342D46A91AF4B2523571DB9E
+ D9930E36CD044F9F9CD79AF60339DE5A2470E31E251353329E8F80A7A5C8A673
+ E0F27D06A7BFA5EED1BDC63C3B9E080E367D838D662DE6449BBC77B2DE01E988
+ 224830B0E59CA61AE85AE56B1088B4FE58CA0461A03EE3B99A9AA2230E00E9B3
+ C57B882DD818DAB9952A254DFB94A25A0F57B83B246FB0432CD9402424BC21F4
+ F318029AC9AD11E3D43F0CBB94F098DC86487D972B745689481987E6F72E13BA
+ 1F6151BFC34056A0FBD53C2FB5E08CCBCF4D27A38D5D2A83232CC5A00A0956E3
+ 16C428D519CC56172C535EF886366D21242E245F50E1722C6C2655FA06054BF7
+ F7C9D5E6A320B7E788CD9A2D10A5BBBBCC09750B001F72115E049BB3EE7E1819
+ C9DBE27AAE836F767825F98110C62DD379E104BCABD0F3A4FF007C3DEE70DCEC
+ C6B095D647116AFA76A09363EB2B85D5D732C39854E9665E4FB972C16D0A2C4F
+ CFB34A420F27CBB0C0CFAC1F7F6244ED6F3EABA34C33EAAA3160A5ABB8053183
+ 92F78FEBE39D30316E3979E7E10D26A3E93801037F8D603668A442750E2D5EFF
+ AC8FD38BC6D89CECC7D1864A25C0EAE4967B08AC9D71B6F43AB53C8D65381316
+ D36AF48CD8C3E7930DD405E8399A44512261A5251F2486220EC74AB6C0FF0B35
+ 1AD34CC1EA0B600E8CAAB649F0C96E77D4B5D87201364C5C109A8938BC1622E0
+ 474981EB1A237B0B40E9B313FC1835AC9F9FCB5DA9B6C5DD0B1952040A234269
+ A231DFA4FAAB8F4CE8E8F7BA3F9414CF5D1E5C3DA99A7872D27AFD7C4DD9B2C1
+ 8B1867D71A443E7F51FBE9FB4943979557E6D68762FE2A8E78A203EA459A5947
+ 25A83CD862F669BED5BB5D16DB595E7B350E8B703A07E173EFC8559960770D26
+ EFF86CCF70ADE6CF473262810716192CFE0E83DDA99885D7AF58927526D2D7C4
+ 6380CDEF7D03E8D3C0256039CFFFAAED22147267EE34783D05EA0039A83C2DE7
+ 61CF7FD9D140C15E4AD6491B8AAF5F75930001CC937844E3B98029CA5F2AC9C9
+ C3CA1ED2E150F7D8D4B1369C9941B3712B60409611A7E35CB8931722808C4FB4
+ 917ACA4D8BE987D2DBEFC6FF2C20707B8C368334E417F4BF89C13752D6A9B69D
+ 9D6F97FDE577FE6C5CD5B55134F665B893147D71A77F3C80D7775EC4EE4FF756
+ CD47F496094788852AAD87D92CEA7D4BBC739695F52D861CDA2457B6995E8911
+ D0F83EC71C10264175A3858FFB21BBF2C6DC8F3AA5284E9EFB937B95D6C46F12
+ C7CEF5AAB13EEA15CF04EA0F79EEF461E7A8554BDB03E3B00D108AC63DA1209F
+ 266D27BAD8BE2089F021341EC8A0BEE7F415F84ABBC71F069D281165D2B21644
+ 5792A12209382B107F7F6933ED6131D16E6D43DFE8EE72AC73758A825C0E0D90
+ D7E859300ECFCDC11C2DE9717C1F4648292D95D8E7A55956D3241F80F6038439
+ CC4E3E4E6810DECDA6A6F27B6833E8279D2DB8652C23606A4A15C8CC46A4CB71
+ 395AAF7B20964319922EA17DEBBA940533E2CCA7C0A49EAE6A63007448970709
+ AF334BBCA2E931895B615CA1D7BB24083DB0D6D2CAC598495DDA4C552D711C87
+ 171DA9CA312E0D35DE880C32ACE5F0468FBCC6FF161CA77EEBD65BBA57144E90
+ 45056207502647919A25A923E0C4CD10BB11C2F7FC687605CE82646C48F615CB
+ 07DAF23D122989E672880662D9558C0C7F893FA0997974343D82D864102B791D
+ 84596C6375A99FADD379A8624888C0CF63D641CD11F4D3C7D44C84A200A49FE9
+ 5BF9AC0709E87778BE8BA27CC2CEFC7152A3CF8868FAF863EC5938E0FB3BBB4B
+ A5F80CBE4BC3B0F5C962F6806056AE6A815B776F568753CFE12D6A642C02F4AC
+ 7B65743C7477650711A91C178635614C8BF6AD5A16C83434A93AB63970B59843
+ E79B5BDBD0F9EBA994A819E17C67087341E74AE0A068014B4421880E461FDE66
+ 2893BB531552231C6A05850D8F91EC091702D01866E79FD4376FF6DF0B0528E1
+ B279C35E151347BD33F59D97B950EFD7C0032543A82EE9DFBE64B033A013D1C8
+ 095337AF16ECA873515B6D7FC99982E52C34D7C481CBF74B0B391EBD1F7351F4
+ BB56EF3D83FB29571C75A74B50DC2D1F4C933851CD671E2F00A960E8E6AC0140
+ 7AC83B5D44329DE12E035128770B66D606D9939AD3C9BFEF97A69AE7CF886C3D
+ F622615930BF71D5DEB58F2C6F2D4DE5B3044559B93EC6A1A728D6594FB61C78
+ F522782598F7190FCBA25329AB421344D5835C81F2D2969631A00ED6B2979C36
+ DC6A867305BF03B11F79A8A3DE07A73B3DB4C242A96C6938483ACA52034EE7BE
+ 15A606949252A3A41C0AB15E07720191E22619E35016F4C904EA50C2D7C00B62
+ F146A4EFF3DF6CD170CCC67172515FD5BDE06E2EC85603CD9596AF014AAD4262
+ 9BC27FD473FCC825960DBC8C3263B5B946D33DBC7F3A6338CC3AC14DC8A57812
+ 124FF632687FD4FDE092D73FEE698DB83B11B64C21388645B68DBA9B93FA259E
+ F34F334C02B94A3588693BC5A3F31452716E94A677073066B14D30647C2EE18D
+ 3F8B91753992A0A50176C89EA3CFD56E34AD1C29D02A5B928D82F65127B7BA4C
+ 74D8BEFEFAE63D5082D8E7FAF9AD1B0D4C2E2F5AB1EF76F9DFA498D224AE558E
+ 54B0C1BBFFEB3AEAFCC869364F02050D8FE0A55C835DBFDC2087FB08168356DE
+ 59EFAD389A461698EB6F1AF71F001EF7D8AB508925714441D79A128B06D86571
+ D13C5BD07213AC196F7D7A1012B8E99C13EB36E49931E381C941FD14D50D2911
+ 9CDAF5C53B5A3E7E40D3514EE52B56F2ABFFC19522E5980FED9DF489E236D06F
+ 3A1DAA4D52FA611704F96E1F5CFC99BB070BB65E7CF42D789F951733787B259F
+ F55003EF44AC0837F7D5F3BF7B3297A5AE289FAED4EFD5AEF271CA1D28EF04CC
+ B58E502C1B800361A0FF29A4383028CB8485D54A4EEAD31B9FCCDA9038CAFB2D
+ B923AAD5BEF5C268231A55AE5B83A6FEDCD08BFC31F788838CE62BF3206F8DE9
+ A3D6C8CD524BDE46B2B767993C1724B6923FA50263BE89789884D5B773D0EB72
+ 4018BE4335DADEA420C8E1761982F07C6ABAE8C539A74B6778A4610556D8BF88
+ 17F78155823A82A468846045CC9B73157B0A69419DEC8633B765367E8FB3E677
+ AB231C36FA41A37272FC25BCAD708A1599C8CD70543EE93579ED5E4446D57B17
+ BC8ADD5757255D0EA4B40AC6A47A3C6327A117C0E39C72181169F6DC86CCB8B2
+ D29081F20DF356377A4FBB5EC0F39ED1AEEB1E9709A9775D9505C2F65608D212
+ 981EE8554D1A411329BFD9E5F028EAA8B8A00566B2BD7BB9662A811021773F3B
+ 4432E41039D12B5D69BE2E87140735B4056B60ABBB23316650B5689C3A53DFD5
+ E19A18D67BD10ECB42C25C9D24B5245E4EE0E6A77D8DAC09CAE0E29B98341898
+ F09207E0EA8B5A586801614F9315CE073B2D438ED69B129A4FDAFC48A1506842
+ A140B0DEDBB3B983D1587990EBA40D0684B817EA197832EE2125077FA7FFBF95
+ 5ED96B74665D934CB15330EA1A5ECA3F638CC666CE0C8DB3FBC8270FA00E2A81
+ B2B5BCBAE9B471DECD15437A430F9EA9E5D33D6949AC8B771CEFBEFB686744F9
+ 92FA162C6BEE59178220ED260E44E0B1A4F86F39C3BB020DE3F8E8974EECF9C0
+ 747FE6569B665051AD4108025A0677F4619ABF2F007EB6C3A07F63B9E90B9A72
+ 41DFD0D6409D0D52F902E34B136AF5820D57A490EEF516B118C51E04DFB7DB48
+ E3E8FA4812EE485A2A55B94D29517A01AE263E4EF448C92269AD9B2731F88799
+ E7644F60B29C0BDC644D485530D9C3746E5696947207D4A229D1E24301FE761A
+ 7A8109E2F33D1420FB600B68C068EC4E2A10D0D5A7E5713730BF6C555E400E31
+ C25CC6DD6C5A320F76A1445D60E680F22661B5A0D401F0362B3B6C1E71596994
+ 2D902A70B8DBB267203F5D61473B5821A56735C95E49822F8D67E3D57848513F
+ 5D223DCDD56CB139286D35FA7667952FB2ABCB445F8C8619576AA1403141FBEA
+ 36E1C2093A2CFE43C689533C4B474D75EF5689889E7265FE2100C3CE641F884A
+ 11A741540582C46D88291E12E99F8FCFE55A9B755DE5FB46EC20FBF8126A2042
+ CB9005558719C69E3B86CD8A0D97A588E03101A58D939C7E1283812AEA57A2B0
+ E3C6F11C371D13CF0F2371ECC111F2A785B9AC024CB7FF0C46055687044FE2BF
+ 20FEF93A5DC42843975DD1CDB2C22DAD2300ECCE7EDEF836139BD2EE072D5E9C
+ 661E753B58FC4E200FD24645B893D2E7EFB74B03EDA4EA26FADD7782D8CE15C3
+ 05A9CE481EDB233CA55181034517F3CCD5A647A4F7A20E108D7AB42EF1E897C1
+ 4BD114ED8B5ED420BCD211652CD1E839E12C5E364895E125747D82F56447D2A6
+ CEA81CC1E60F60BCF605DBF602CC5854A350A341457FD0BCC1A91A035DBEC0EF
+ F9D4601A97CE9346D542C70DDD90A46D816E48DC5F9AC59AF3012D80FF89591F
+ B36D2185D5D02713FCA171425A199B4C8F01305A33F5A917B11E070AD940E45E
+ 1F5A6876772EE6F0BE2C35DEB09F3769B9A4D98145BD702D3A9690C9DBC25C96
+ FDB912F9D8FE79E2264079048FA7CB84368A2AF64FADA99B6F8F6BEBF9A0F0D4
+ 547FEDD616F1B69F3621DB0DC5D5FF62BDBEC1843A01B735C131303EC530DF35
+ 68CDE5CA43697C4E1268EFDABA63F196864B225E525425834C689235432B0B7B
+ 8E567F9D756E546660B0DC23E1808AA9EB12A87269AA6411BE5051A8D95C5DA4
+ 8B199715AB1DBAF0EE0583D6552203015A0887FB401E264B0131FA7522657C6F
+ D777B73108E0380C9D306DA470A8DD05176B05B8DBD5A49EA7B8457DDE003D21
+ 6780F28D1F85074CF4B7DADDD10471A7B03AB60A43E1011992B5E25E8034D09F
+ AEF9B73E3A01724EC3176B3F28EDB15D0B2003880B10683967925E3DEB40206D
+ D1A94A60331CFF31A040F7D4BE3400BDDFE49D146139CD36A85C4C90F9B3AFF9
+ AD627EC33D83C46F81E4696659B7179A2D44F3D2591830517DDB5FE76DA0A7D2
+ 72B62A8ABFBDB4B19A6C8D9F2D0B2BEE977C80BCCFC677F2C593D73C24CE651C
+ 6B440DD98BACD38AD5663518A81D03E1153810781D8A9E080EC197855464054A
+ A8EB4F78DD159EBEDAC86271B7710B7D58CA8E51D03DB2985A0C71559CC2FD3F
+ 8C3E9DAEA19137ED81041523A14B36BBB9867C2A6EB3B3EEDD82DA194A8A553C
+ 35AA0F3D074026534D602B55CC88C7C4794F1C7287F275FBCAA621A9795906F6
+ F15E093F6164AB4839F9C1679691D12F15DB2E6E8FF8124EFF5B2F4CE8C08844
+ 05F6F064232D70332CD35E7455E5F079AAEADC88A4B776840596F3BE64C735E1
+ 71F63833E5DD887A0A571CD74054634B26A97C1ECAA4AEF6E02B38045D5A7ADC
+ 03BCF9CD2A33FDE2440A9C4CEA18258ECEF0EEA354C44AC78F6FE064F61500CC
+ D9538A3E42B93E3A1EC394E3F365416AA92E9C20094FFA1968F491133C4F01D0
+ 9B714789BDF9203DDBF4223342122289C96CFAB01C10D0C0C631F322F43A351B
+ 0C473615ABDA1B375DF58EEE257A0F95CBB8E8252EC99F6C2A6C491C9E19A327
+ 1FE75DEEE18DE5C73B5AF61A8A97A7C88DE78290E448CCD749FC24AF1ADDB0BC
+ 1E631A5ACE6FE7B7261E7AD7479F975A1DDBD2B051B8F159A3806187C76831CE
+ D01524FD1D3E879E4B0E28FBA965B9ABD63CABEB5BED134D994CD15CE0378752
+ 5F9275ABE95C9BC8531B737FEB86850F72845EA2963460D203907F5DFC44B217
+ 0E485B4EF415C7C954132717485735563D65AF28B944839EF73AF8C5B78EEA31
+ ED16E9FBE0EADF33867137A81F76D9A632CED0D8C96FE2BB9801E601514F3615
+ 6C4105C7AF9C9EC94AC027FD8BADD81D7A0AACDBAE8864F784A9292BEC723888
+ DBDC17EFE1BD3D235FE1BA85522B23D9719700B062920C6E972D14DBB959095B
+ 6AEC58F43FBAD49A87EB04BF63BF95149B2E2CC89DB933D577337A3AD37740A0
+ 965FE340397DCD1B78401E8EE27E013A48A47BA0EF9EF2C1BD47F1675CF0C5AB
+ 9FEAFCDCF4A94EB1FE1D0671D2C00DDC9ECCFC2B60AAEABB04C8664BEEB6B44D
+ 6D84F999BFD915F6ECD0159839FA5A70753A860820A2546661A032F30BD2803A
+ F2326F7B9CC718AE23C30925C27C097B5B3DA26843942861075CCBBFA25CA118
+ 0D3447473C0D53D1988B39CA4210B6BF1095DD226B21A692E27C7A59D118B0FA
+ 51C5169C154F467043EEB378072F3137D8887D01895897974AB31167473DA1FD
+ BB0C485E130B4F900F5518BF0CDA5ACCE1E5A02B25B3CB47538CEF3DDB66C67C
+ 2E7B6900E69F32CC2D9A94A6F278AF33F273E7A99411B360BA6FBF938045F547
+ 7406A14E62EF2FA3951762C0D26F139E8EF9DB4D7F60034EF53F7BC0E80B8934
+ 7CFDEF27F4D42383056FD797691E94146709DE502A2C7C7867F189757408DC32
+ 269455099E0B5C70654A98801835C35E8F33F22AA602C58400F250A340A913A7
+ B65F4BE6BC79BEF2C5FDD592E210FD02BC4D3C4BC7B7F58C30019B4F3819E874
+ 5515FCA4178C4CCDA4BF5D0AD379AECC9AFE97E342392C7292F42147BBC3128A
+ 26397A4A2EF25C1E678ED8024B1CBF5702975728753F2F177710969F55D44EB7
+ BE2572139454B05A9D85D45B7CFC5C062D984DB9FD8B57D0F903E568E6460B7B
+ DC95764B0297B6C475C904CF3E0DADFCC24A1597CE86D6E1C919481D62E2515A
+ 5722C8A1C53D1906E6207D67E2991BCB5E69DA250EE3B5BBE66D843309547065
+ 9C22CFBFF4750FE5A3F6EB4E21EC3C3BFEF0D0BDD79CAD89E30C1E727A024AC7
+ 8B9AB1DB7D23BD01559734E64574120A3AC04EB5512FBEC6CE82D7C6E632E834
+ 5D420E5A597681E6DD1BEDEC86268F04AF8286A2CB068D73460B0CE5C62500FB
+ 3E761540CC25EA34AE8E44C6BB708DE7C98730A83A713BD7002B6B86793EC3FF
+ 248037F1C7626C034E7743C401A724220167DE5C2172012F749B515F7F043E0B
+ D2143582BBD8E4587B5F1D8C1D834B3D1DB5850FB9625C7BC4746E581BE32441
+ A539C707455106EA4DB669219AD2A91B9012701E46FE4CD41F368921B52D3E0D
+ 289950EA026676FC650A6F2F01206BD677366FAC2290364AAC464B32CA886167
+ 0512C7BD444C5730AEDD0736DFC339F8AE1176EF7969F1E918BD4B5E685E43BA
+ 3457C92714CDC96D30B97EDC5C4813056DBCF38CF7925FD6FBACDF3663741411
+ 678F1352AF221CE5C74A278C6DDCF645BB9F377373FC5DDE005304D0194AEDB4
+ AE15F5B66D9AE2897F0CE9D4FCF9EFDD098AB272EC4CE618FF94FE8268C362EA
+ F2B9727EB5210A3D86D0CF7D31D06B7834DA42BF825B1C14FE65442EDA122F7F
+ EBB508CD43CA9DACE2A813BF5048AAD50E19B90559F1C466077AA6765D9549C4
+ 0AB13AD7DD13D30EAABC842C0BB36B67EC36FC7EC8B1309671DADD928184899F
+ C26D8735C8780AB0F7C64D980E799766FB7E14AB834C0D3D921384DC786B4C8C
+ ADF9677D0E208C2D98D72ACC3D2EE236FA20C85E75305E615F469F5E8C14981B
+ 23F7370E4F0F3AA8C6122C4209DA2AB76391E19483F76E46BD51EBA1F4ACC270
+ 21C1BF8EFED1B8B797BBAAE0AB2643524233E3E68F0AFABBCD2E00DA151527BD
+ 0A48EAB02929A80918914668AAF01BEE63F8726086A0DEB573071E167638873A
+ 3C16D55B1789E7569B1F1014918DCF6C864D66C1DEA26C2EE6E43B3DC48D62A1
+ F94E13DE0CB7E6A1DE618E0F09230F44CDFC0CE589FDB82853C92D29BB4E72CA
+ 3CA2C2CF9718E5853835022E0F489AB66A6A8724CA841D905AF48CE2111DA8EB
+ 2BCFB987DAE79AEFCF7EBFA198EF8713039CD043071333AF695703F8183EEA95
+ 7D6C23D58E98803CE6A2CA69562D50461BBCE6FBFCC835CD1B81B29858504061
+ E2D197B0CFD0C0EC6B88EDB9EBFBE29132B93DD5E0A041802278E9ABFF391780
+ 0D8EEBDBCF09BE24DCA3CAB61E0D6104C01A53987EE84C8B0CCDAAE30E166286
+ C54C5F58D3D459B328E70E6B4BEF4C987DE7D4CC3DD9E057A6800FDDFDA3F0CA
+ 5E71FE4B651FBE3B06E3B1F58CADD9B9E711ED238D9711D82ECC2AB5CD101D75
+ 01C2041209CCE11C1C07DD32BB9876F202AC0ABF995504BC2814EE1171F02E33
+ 805EA7D9149E37C565BECC4EB97D5083BD1BAAAD8F843311E2331E4C1C52EA87
+ 6E9F0572C79B0A080A8D16C6CA5EAA075B46A2A83FB9B1B7FC5E3E0CF1DAF9F7
+ 476C127BA432EAEC49F88BB99C0F58A100B192693E0731210AE3FAFF8339AA80
+ 57574F87E48E7F26F02C1CA1D4B059EECACFA0987E6C270A67B828B1339114C2
+ 9E3E24DC5FBAB604307C5A629C4C287ACBB8E882C5E2F806D9A0893124DF53BA
+ 5844647688E067EB643F232A6C7D44EF206B486244F3DE7829CBD87AEF65D527
+ ACC4598E93A493EFBE15C6F2481285CC4F8B36E4376E023C370744B10A1929A2
+ 0A6B234D7DF7FBAA423C3DD72CFC8AD2580E63F72085C6017FD24E640F93802B
+ CEA29ECDED208D9190788036E0F344AA01712EEB48E713B9F3B27D73F266A26F
+ 2549E4E672F10ADB607824770817DB468E73D2C2B5EA20A617FAF0B2D80AAAAE
+ 2965486D375209EA5FCE0EA0EB24B9E30ECF40945FCBB62662AAE964F2AE6175
+ 6516222C3E60B773A633F6E003676D6365AD8386C520727CD9F935C64D45AC5D
+ 73E3561D0C23C268D43B7331B6F4342EEC845E4FCBCC73360876ED3D9389976A
+ 5520C6CA9BD58CB1BF91FAAD7CA4D4C81C3EE2B3009B1F0B7CFB1CA3644936F3
+ 7E6C5AB795A1BB6BC6E962F8CD86FF24403E0854EE4B0E79EE7415C561DD9090
+ CE6FACCDA34A8D1A6DD1A3038095E964B8D3E1D0D0EDF1F4641DA636D669AFC1
+ 9BB252015A235EEE772F9ED8321FC1D672B78C24A2D673F1A5EA9B4B881BBA64
+ 36BA5FFD3EB6AB312E0A5BA06B85ECB3E6119E478A1B05D5195DAFCD14A81C81
+ C6E765D3A5E0CB631BE4366EB182979566D3E4A1F369BDDF2ADB2B839EE60590
+ 078F16CE329BFD63152CEC7F1283D810F0EB27F3AA5A7B6842C804D2F9BCCBB8
+ 203A14A5E39E8CBABC07CBEEE11FE72A8D859956733F613C5BD9C82A6811B8B8
+ 4ABB2895C6B8DDD4F65E6ED0FFAD2DAAC3E276023B20FFC10A894AA394DCF970
+ CCD2A4FA6B1B98392D7320F1DAECF6FDDB1F59F8379715F499BB03B6EB07BEFD
+ 26017B478E454924E61C9BEA9615BA47259EE50C717CAD46B0FF5BEC34659156
+ AF170EE936617A5308F365BD944D62746AE4DED312BB931B5105EE0BA07810CD
+ B93267E943E88449C4B3D67CA051FC61F65667860AF96619D6694A026B3F0177
+ 359CA2A7E315434FCA3D3CB124E95EF30A1C671000699E19E4591964D92A14DD
+ 049A86430A6285F573FF62A2448757B9D68114ADC40190A7696A3F1152972866
+ 055A6F897A594A5480EE968979515EE678641837736280CAA5B16171156DEC5A
+ 98623A718A291B7751D9998AF0A6968F11F1788D8BA93B341344958075B14E91
+ 08067DED8C2AA36EFC1E39F9A374E54F9CF8CC5044448945CD4DD3B344F69B09
+ 7EDC76ED34837E9FC9074E2ACA1D753032379DBBC84B38D48D35466B23AEE8CD
+ 1DE3C46AE242A26F6E8D50304DA3FE3A59506D19E9AE01F1D824FD2A672C4185
+ EA029E9763EAF2FDC27642F22BB1B80ED48FCAC22C8D83F33DD63FEB1D1BC517
+ 23157422CB9834C195377B72AE24637650546175F1462EBB38A092E2EE76D578
+ A18EB88CDDA06F59326E17C7A75A320FA3FED936EC375DAF64F879AFE2B6C99E
+ CDF1FD50D382FDBF53D1F6B6F5D366D779DE916F925BAD3A7B3E102ADAA68ABA
+ FD76D464BD48A531DBC4DE15F2DAA7B84BF57F320371C073F709F80327F74A18
+ 53F6E7A375C782149B02B7FB2BDD200A6339E9157964136A727C81408DDEF0B3
+ 736B6FDB582B2ACBAAF6050419A053B96B421381BE7E17B80701B4B399E15C82
+ 7F1E24749ED14A54FAD568FE080662D4FDE7AC62EBF482EA13DD59E2E5F788A5
+ 07C273215BBA4549F04DC2102616F8E035709AC8403B19D8D1E909E9C82E3283
+ 9BE45215533E1275809B81DF21A69E9C7F6EE5F57D695C5968A830C8A2D748C4
+ 0225398142D28188CFE3FE1EC8A698EA99BD37B7DDBA3F4BDD5CCCE8D169F30D
+ 08DA9ADFDD0D048BC9947848F948288EFBC65C7BA30F51C73EBCC9E22999518F
+ 87E42525AF36D31EE2F9E070C27EE145A089CFDB2546CED205DA5350B54E1CDB
+ 32418BFE93A2707AEF5B959AB39DEC2B48A97378308B1B6D27D095FC8F1F055C
+ 713FBD2C32ECDE04AE542EED162C345EE25B613F2378BB7A7CFA93453293D930
+ 84C68DE0FD514B9850FFFB9CA1095FD42A3B5796A5B5F18F6909A224993C31D6
+ 05A7B464BAE339B9202F5C4BEBF48DF8ED02A19F601A1338F9D0AAE3246B0C86
+ A1D1D4B4508D02B3EDFCDF3E2B178B2CC57E241585C2FFA941A6F1BEAF48E419
+ 5F5BB1A467CECE15D0AC7EF64E8DE9E2423799C73D49AE6314C748A505B73B28
+ DD462A07084DD0035892F01CC54EDBECAA6ACEF0DEB3EAC06164CC6C42B05E9F
+ 141491F04C7F2C5705866C7C5EB45BE236BC22A635F89B95CC8F481400E58F20
+ 1D86C24B5EE12F4786327F551EAE77B29417205BE57B5FE116791ABA229D0004
+ 2FDA1F67B81D0BBB3BE5DE32516820990E91901CBB68E5E0C2F7A8DE85008D6E
+ 521C67F4027438B289B615EDFB4A472B0D4D1B83D22203F0631F455D3279712F
+ E0F2958A92394549B993102B54B1EA538B3AB20E2023E83EB2F84C9AE6EA75F7
+ EBF5C8A467237F76DC28343BD2D8718D3016BBD8BC20CFD0F0AF881197D6438F
+ 81244B1DD969893B5D1A97BC7AF4AFDD7DCC9876E89FA704E7909D27667163FE
+ 9A6F1E99900B8C290685BB9341977D7126F4A4787FDAE7E478AE04C990A2B070
+ 6E33269C0502DB2AD97D8C745F07007C0266D0B686807A578FC4E9DF6EAE56B0
+ CEAB08038818C1A00795CB337993CCB392FDD92A645D7D1A680D067875E6D3DF
+ 2AA149044C5ECD853E95951B954575949A4B55B0A39DEA47E78362DD02754A95
+ 9958B6D646BD87ABB705D151CB3880F19BB63D0F83BE350D92DAF795321DED0B
+ CC23BF45A91AA2354665F9CFA2F5207CEDEC7D455AE6E8A7FB6DA83A3A445D14
+ F7A7465BEBE6F173873A1E87772025EF2E9398555A2648DA1472E164D73DDA0D
+ 8DC6ACCD65D96A3A705AF18D9FE9E480D3044AB8E10381ED802C83EF4DEAFD8E
+ 91BED74DC5C469D6ECB1F341F27FCFB357A88C753BC287BA5F6C17D411940330
+ 73D3B72FB25CA7BA050FBAC8109667C3E543778B15CFA6FEC2A09BB4B726BE69
+ 49C5CC3A4152D48144255C4D289E06D8FCF3259093B594B159EA5C4D0318D485
+ C3CB7A0D04F66767798C888E70C4F4293D87E55E9FB2ADF046B55200639833FB
+ 5F308F8B384A3CA43D49A320DE491E622906B631BFC8721AC8DE75E9DBB5E333
+ 9E715443B8C8208235E405EE52CBB461E4A9C972D107C32AA96DE99E430E0E92
+ 2A8BBFBE5ABC5B6C746ABC4962D09337A09AA393BDFA96E204B07163D97C29D6
+ 85A90C8656C4E793984AF59B407AB386F0EA33D14E97FD4EEFB405A2BFA23DBA
+ 48C60B7264CA0530303281D4C322E7C3296C02D443DD6526CAC6AADCC177C110
+ 01AE5F3C8DF072B8F1007EA11B8A6A70229120F0B1777E2A15D50C66F6FB9CD2
+ 44E010676F323393580E193E08719F500C4F826E41464981EC03610B5F83A591
+ EFE25AFD9D229CEDC2E3B0B49CB585C7C3A6BDD0DBA6BFA1DB6B8ED902B5B175
+ 700F8DCACC13D1B63FB3782E4C9ED619F62916D3DFD19DD1F611E094B2B295A5
+ 9C74E23C16E9915CD8D0DB3A851B69E00B700A00DC5A9778FC182608DADFBB4D
+ DDAE36293A84B8AF634D15D214309DB2C4C6F8FB1CBFE270219850F923BE5B91
+ 0B748E1B67CE1438F4498EA23F273EE97294111458710BCD7A32218ECB957F80
+ 3929D15127606F15C3E11CD05D6ABD93ECCA9EF2CD62B68FB4FBFBF323ADCC9D
+ 523C22A5C5C69685BBB19EF32B76B233F98C2154AAEE2A391B476E68FCE976DB
+ E8B4419C1B749C9A15097072A20918E5EE109089030AADC252C0E131F4475259
+ A1B5D605A12B16716D7020FBA0A45AC39712AD6AEE8AFF7EC2100E26A211058D
+ 03EE247F7E69D39F7130C795E26EE09086447F99916E3C07A1A24106421C4A5C
+ 1901AB0776D0E1B55DCB2F49A71CDF1E7E6B1E78D8118B672C968C9312265286
+ 78EC4162F5000A0D791B44CCF8A1FFF4F141BA3477E366188D2D7659CB22A897
+ 6D9A471B6F16EC16DA857DB40E0F48BD912D96571F2F963D86A173E4472F55DD
+ 1208DF07715D33DFF00C664227F6E30A4166BD3619E79A0D64C0754629ED445C
+ 7D79F583278F1656982C4E879B8F9D6E13D7D44FFDD7E420D642BD324106840D
+ 9C20F3EC0B4260963FCD9762AF9A29B64AB071F5F7F970FB7D8B8498ACD2C786
+ 2C8748D4FB934AA97C9823C52F1E36E35B1CDA1C98C3D84F1F3FBC73397F316E
+ EB64A41B14DFD6F9BA7CA561FA0AD0E502325BC582B5E3A1757414662D9ACE54
+ 316399E2B506CB85047C77F411D31610CFFD62AF623BCE049453ADCA81ED9E93
+ C478F42B614BEDFB743B4E69D72578D9DFDC32E0E0F496C881F8204C92A333BC
+ EC720CF64656001773BD42DA747250B439BF6C8CB6565E00EF714839876A4231
+ 5A991379494A2AECF79559DF45082F0368DC78A40156F1A8D7B3225B75EF70E8
+ C0140B3D59C71BCF5503A92C801CC9CA4C5561CC0E7F26B03808109B3A0E5204
+ 89D8E898F0557A2B780DD9EC2452A0C6643990E6D4ECA6F0ECC03CA43B39F9E7
+ 8A3B647D14BEF0434E66453E5E596E0E6CE74CFD8D4F09D219441063EB8180B0
+ CE96D78932C8C781AB1CF5FAD4CED46043675E19CCC06855871243BEDE14F169
+ 03CB5DF46D2C2C59E54A750CAEE9B60A2FDF5CD4DD0011E1BF9FC1BD6765F448
+ 24EA05C1E0631AC96C85C6FCB6ED17C2606574B0F03D697329F0FEC1A1F05276
+ 5A37BDB5F9F50DD65A5356AF2998AC3F9449B6E0623A20EF8896F5AE56357081
+ C42F8B5C093F9611A04CF6CBB74E9A39A89FEFD65E6462334010B4B7FFCB33D2
+ 376C6758ED38315D928902796772A9B7C7B814026EBD54CE1E161D3F5CDED849
+ F3BF2E85495C0E63BE196E2997502DF20A9BBF66B2A07AAA5C4B400A91E090EF
+ FC6FB2B0E8D5463DDC02A19371C6336CE9D38CB0EB87801E7E923A33689A2FBA
+ 1BDC5FA32DC829D65A06A78F927F6CE6C265158DC6253C71678850360E0ADBB6
+ 25BA6B5703D2DE43E4D9082A88925EC22C6C36929C77EBBA66367696CFC09614
+ 713BE610B497A60990524D1C2A891C4ED3A92091D7A6F1DE2970B355E90001E5
+ 763F1EEF4090AC77BC80893D0FCAE0EEAD6DCE05663047C7A81FF5080C5DBA9B
+ 4D980E678A21F1F4A2F49A1AFA5689EE1C0461EA51832593B15438251C439E1D
+ 5B6A3241A57254C59BF9C555A498DA047F047FBF0E94A4917655BA9B1990E7D3
+ 2CD81EE10FAE05B9805FA63A9EBF7F089F4A7CE4F14AE327FF044EF4BF4A6B62
+ AD00B5FED85930518F47CEF67A4BC750F32AC49AF87F6ABF62E8BF68B8DD2751
+ D648CEBC80953CE3A4D3FE75150AEB3AD318BFA187ACDA5C132A9E54A7EEBC52
+ 0C5DCBD810FAE313AAE4DF93541594BD44A0A2070DBADEAA4A478CE5FCA4BE1B
+ 4359AD1D64D85B9665E3C41EA84F64CFB68007D51ED4A715E138841E082C6374
+ 6AC8C5954B7F0C62F5E395661A260BBF71FAA7153E59388A18D145D26BB8DBFA
+ CC531BAB0FDCD2F623FB802A3F0524BFEEB77609A7009FE2C275F41B7019C686
+ E0963D793208BAED9AA2F91EDFFFBC059FBF4BA66875293850E56F47B0308842
+ CAB4E928B42070557EB78F31433D35BEA7F0FC84898E9ADC98BBC133985BBC02
+ ABC2584916529E5F531BF53B1C323970E8B325F4B7DE5AB362EBD3ECA7198A2D
+ C473C393F2A6C2FCE5F822ADB74F00BC8D5478F2FBC039190E9E81014E6E43B2
+ 5E8F162F80F43BFA8D8720C92EE17F5C7A45B4A4E08611DB53C0E417C513041E
+ E1D9F29A6BFC8D2EDDC6752D5C9C228ED973E19D9610F9BE7727E039C69D7E08
+ DB44E2574D45585BBE6CD2B98FA1452916AC968A6B6D18BEEBCBB38B299D69C6
+ 98A360F30BB34CDA26D8EC4D515E5BBEEAE4A8193AEF12300433E2C7562F78DC
+ 5035BDC54E208F0D9BF370812AE714A70173FEE1FB40AAEA25171E204608E318
+ 45AA675336DDAE74DFFA66D5FBC048E84FD86C4932DF305E17AF2C321B66ABA1
+ DE6A2EA2EA88D6985DDAF510FBAEAE4F0D7C44841D3E77204A9E398BA57E1950
+ D88F0D3C4B0F491C19079BA97DB5667E447B4012B9A648523C0B2C5C5FE4CE80
+ AF3DE3F9388F0D00447465B6666A96D577AD610575B60CFECD7B45CE0299042D
+ 33CDA5FE6837FD8F0182CFD3CB3FEE8A9BBC293534039CEC7296554A08B78D37
+ 575B69721EB73CD7B412F7927B0633C55DE86F0B8437429F7F59EAC5504C46E1
+ 0E8D3AC90975F66428BBE23E3D3EB98AEEE5357A20FA1CB71656286B3F68C914
+ B185C79CE2108DF4161AE6B39954741A1F69B9FA589BBA1B4C790BC8ACE5A4B5
+ 350D42E61DEC1810FF7B9836A4CCE8ED0228C975ED2AD13E4E6BBCCF099C919A
+ 0466CCD0F008D2D9F414123D552507ED64229DD3C98E777F372FAF175DCCA933
+ E1A5E82663BEA6D3AC3B3EBC90E30EF8F1FE6E5110438C8B32B66F8FF756B5AF
+ E863F93C055B5683CFAB6AFFEDA42E99844D254736944625BFA2C3750ACBF5E2
+ 54348B150DA0777B6CC7A43D872E058219866CF3971E8F175751A3933647E89F
+ CE77C50E3C5E9897606595A5B1195B478D1F3D4F78E73843EFA949BC2AC8563F
+ F1DE88E3BACB36576E8B8A9C9BB31B19B81F667CC915D134204985A6A458EEB6
+ B38E315A76158193942BDC92C440DC5EE7B0704E80E979041D1028CA4AC84EAE
+ 275F42662868291DACCC3880503232D346720C1E2A1B0DC020266F08827AE29D
+ 167C14A226AEE569C859A2EDDA2B595A8184358C87186D3BC32BB8918D4FB7B2
+ EDB081DAC966168EDDF09EE93D99951BE714AAACD61D7B4225274C1C66B834BF
+ 8633A118065C2F6F23ACFA6FD775417CBDD79175E0073C8922C7EB340C836EAC
+ CA09129F0AF464EE5FB15A4C1C75C209C1337261CDD537B58C7BF8E139640EAD
+ 8C60AF75B4D06DCA4E41C25FE1BAD4D4CDE66CE111BCA81C4E4ED28A91D97C83
+ A5F250798391537A59302CEDD32C44FFBE778CA28329DBB76770801BEB3B4063
+ 1AE07008AD6A16353C8A23D4AFD9E69F434FFB8BFB011BBB425758564302B40C
+ 6E564374D8BA71BDE34650D5DC6C7F6B297BA313181392CD5C6C5786E6910232
+ C66D9ABBFE164819980EA2E487A9BE843C9BE1149BE6F568CA7B2F0030628D7D
+ 1255F0775CE08AB2A05AB696D3D23AB5EFE2604E8DCB22DC999A7BFF207A92D3
+ C4E71F680683A37E2085C9C7D04FE0575903AFDD1354A55F18B8138340534015
+ 01302A
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ 0000000000000000000000000000000000000000000000000000000000000000
+ cleartomark
+ /BAAAAA+NimbusRomNo9L-Regu findfont /Encoding get
+ dup 127 /.notdef put
+ dup 32 /space put
+ dup 33 /exclam put
+ dup 34 /quotedbl put
+ dup 35 /numbersign put
+ dup 36 /dollar put
+ dup 37 /percent put
+ dup 38 /ampersand put
+ dup 39 /quoteright put
+ dup 40 /parenleft put
+ dup 41 /parenright put
+ dup 42 /asterisk put
+ dup 43 /plus put
+ dup 44 /comma put
+ dup 45 /hyphen put
+ dup 46 /period put
+ dup 47 /slash put
+ dup 48 /zero put
+ dup 49 /one put
+ dup 50 /two put
+ dup 51 /three put
+ dup 52 /four put
+ dup 53 /five put
+ dup 54 /six put
+ dup 55 /seven put
+ dup 56 /eight put
+ dup 57 /nine put
+ dup 58 /colon put
+ dup 59 /semicolon put
+ dup 60 /less put
+ dup 61 /equal put
+ dup 62 /greater put
+ dup 63 /question put
+ dup 64 /at put
+ dup 65 /A put
+ dup 66 /B put
+ dup 67 /C put
+ dup 68 /D put
+ dup 69 /E put
+ dup 70 /F put
+ dup 71 /G put
+ dup 72 /H put
+ dup 73 /I put
+ dup 74 /J put
+ dup 75 /K put
+ dup 76 /L put
+ dup 77 /M put
+ dup 78 /N put
+ dup 79 /O put
+ dup 80 /P put
+ dup 81 /Q put
+ dup 82 /R put
+ dup 83 /S put
+ dup 84 /T put
+ dup 85 /U put
+ dup 86 /V put
+ dup 87 /W put
+ dup 88 /X put
+ dup 89 /Y put
+ dup 90 /Z put
+ dup 91 /bracketleft put
+ dup 92 /backslash put
+ dup 93 /bracketright put
+ dup 94 /asciicircum put
+ dup 95 /underscore put
+ dup 96 /quoteleft put
+ dup 97 /a put
+ dup 98 /b put
+ dup 99 /c put
+ dup 100 /d put
+ dup 101 /e put
+ dup 102 /f put
+ dup 103 /g put
+ dup 104 /h put
+ dup 105 /i put
+ dup 106 /j put
+ dup 107 /k put
+ dup 108 /l put
+ dup 109 /m put
+ dup 110 /n put
+ dup 111 /o put
+ dup 112 /p put
+ dup 113 /q put
+ dup 114 /r put
+ dup 115 /s put
+ dup 116 /t put
+ dup 117 /u put
+ dup 118 /v put
+ dup 119 /w put
+ dup 120 /x put
+ dup 121 /y put
+ dup 122 /z put
+ dup 123 /braceleft put
+ dup 124 /bar put
+ dup 125 /braceright put
+ dup 126 /asciitilde put
+ dup 161 /exclamdown put
+ dup 162 /cent put
+ dup 163 /sterling put
+ dup 164 /fraction put
+ dup 165 /yen put
+ dup 166 /florin put
+ dup 167 /section put
+ dup 168 /currency put
+ dup 169 /quotesingle put
+ dup 170 /quotedblleft put
+ dup 171 /guillemotleft put
+ dup 172 /guilsinglleft put
+ dup 173 /guilsinglright put
+ dup 174 /fi put
+ dup 175 /fl put
+ dup 177 /endash put
+ dup 178 /dagger put
+ dup 179 /daggerdbl put
+ dup 180 /periodcentered put
+ dup 182 /paragraph put
+ dup 183 /bullet put
+ dup 184 /quotesinglbase put
+ dup 185 /quotedblbase put
+ dup 186 /quotedblright put
+ dup 187 /guillemotright put
+ dup 188 /ellipsis put
+ dup 189 /perthousand put
+ dup 191 /questiondown put
+ dup 193 /grave put
+ dup 194 /acute put
+ dup 195 /circumflex put
+ dup 196 /tilde put
+ dup 197 /macron put
+ dup 198 /breve put
+ dup 199 /dotaccent put
+ dup 200 /dieresis put
+ dup 202 /ring put
+ dup 203 /cedilla put
+ dup 205 /hungarumlaut put
+ dup 206 /ogonek put
+ dup 207 /caron put
+ dup 208 /emdash put
+ dup 225 /AE put
+ dup 227 /ordfeminine put
+ dup 232 /Lslash put
+ dup 233 /Oslash put
+ dup 234 /OE put
+ dup 235 /ordmasculine put
+ dup 241 /ae put
+ dup 245 /dotlessi put
+ dup 248 /lslash put
+ dup 249 /oslash put
+ dup 250 /oe put
+ dup 251 /germandbls put
+ dup 0 /Adieresis put
+ pop
+ end
+ %%EndResource
+ 
+ userdict /pdf_svglb get setglobal
+ [/N10/BAAAAA+NimbusRomNo9L-Regu -1 TZG
+ %%EndPageSetup
+ n
+ 0 0 m
+ 612 0 l
+ 612 792 l
+ 0 792 l
+ 0 0 l
+ q
+ W
+ n
+ 0 -0.099 m
+ 612.099 -0.099 l
+ 612.099 792 l
+ 0 792 l
+ 0 -0.099 l
+ q
+ eoclip
+ n
+ 200.6 641.4 m
+ 171.8 641.4 l
+ 171.7 641.4 l
+ 171.6 641.5 l
+ 171.5 641.5 l
+ 171.4 641.6 l
+ 171.3 641.6 l
+ 171.2 641.7 l
+ 171.2 641.8 l
+ 171.1 641.9 l
+ 171.1 642.1 l
+ 171.8 642.1 l
+ 171.8 642.9 l
+ 200.6 642.9 l
+ 200.6 642.1 l
+ 200.6 641.4 l
+ h
+ [/DeviceRGB] cs 0 0 0 sc
+ 
+ eofill
+ n
+ 171.603 728.802 m
+ 171.504 728.703 l
+ 171.396 728.703 l
+ 171.297 728.604 l
+ 171.198 728.496 l
+ 171.198 728.397 l
+ 171.099 728.298 l
+ 171.099 728.199 l
+ 171.099 728.1 l
+ 171.099 673.902 l
+ 172.503 673.902 l
+ 172.503 728.1 l
+ 171.801 728.1 l
+ 171.801 728.802 l
+ 171.603 728.802 l
+ 171.099 651.303 m
+ 171.099 642.096 l
+ 171.801 642.096 l
+ 172.503 642.096 l
+ 172.503 651.303 l
+ 171.099 651.303 l
+ f
+ n
+ 171.8 728.8 m
+ 229.5 728.8 l
+ 229.7 728.8 l
+ 229.8 728.7 l
+ 229.9 728.7 l
+ 230 728.6 l
+ 230 728.5 l
+ 230.1 728.4 l
+ 230.1 728.3 l
+ 230.2 728.1 l
+ 229.5 728.1 l
+ 229.5 727.4 l
+ 171.8 727.4 l
+ 171.8 728.1 l
+ 171.8 728.8 l
+ h
+ eofill
+ n
+ 229.5 728.1 m
+ 228.699 728.1 l
+ 228.699 673.902 l
+ 230.202 673.902 l
+ 230.202 728.1 l
+ 229.5 728.1 l
+ 228.699 651.303 m
+ 228.699 642.096 l
+ 229.5 642.096 l
+ 229.5 641.403 l
+ 229.698 641.502 l
+ 229.797 641.502 l
+ 229.896 641.601 l
+ 230.004 641.601 l
+ 230.004 641.7 l
+ 230.103 641.799 l
+ 230.103 641.898 l
+ 230.202 641.997 l
+ 230.202 642.096 l
+ 230.202 651.303 l
+ 228.699 651.303 l
+ f
+ n
+ 229.5 642.1 m
+ 229.5 641.4 l
+ 200.6 641.4 l
+ 200.6 642.1 l
+ 200.6 642.9 l
+ 229.5 642.9 l
+ 229.5 642.1 l
+ h
+ eofill
+ q
+ 180.3 713.7 m
+ /N10 15 Tf
+ (1) show
+ Q
+ q
+ 187.8 713.7 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 191.6 713.7 m
+ /N10 15 Tf
+ (lo) show
+ Q
+ q
+ 203.3 713.7 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 210 713.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 180.3 695.4 m
+ /N10 15 Tf
+ (2) show
+ Q
+ q
+ 187.8 695.4 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 191.6 695.4 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 198.3 695.4 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 205.8 695.4 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 180.3 677.2 m
+ /N10 15 Tf
+ (3) show
+ Q
+ n
+ 159.399 651.303 m
+ 427.302 651.303 l
+ 427.302 674.001 l
+ 159.399 674.001 l
+ 159.399 651.303 l
+ q
+ W
+ n
+ 230.202 673.902 m
+ 230.202 651.303 l
+ 427.302 651.303 l
+ 427.302 673.902 l
+ 230.202 673.902 l
+ 172.503 673.902 m
+ 172.503 651.303 l
+ 228.699 651.303 l
+ 228.699 673.902 l
+ 172.503 673.902 l
+ 180.477 669.141 m
+ 187.38 669.141 l
+ 187.38 658.998 l
+ 180.477 658.998 l
+ 180.477 669.141 l
+ 197.694 667.683 m
+ 208.719 667.683 l
+ 208.719 658.854 l
+ 197.694 658.854 l
+ 197.694 667.683 l
+ 214.677 665.901 m
+ 220.662 665.901 l
+ 220.662 658.854 l
+ 214.677 658.854 l
+ 214.677 665.901 l
+ 209.277 665.901 m
+ 214.227 665.901 l
+ 214.227 658.998 l
+ 209.277 658.998 l
+ 209.277 665.901 l
+ 192.366 665.883 m
+ 196.821 665.883 l
+ 196.821 658.854 l
+ 192.366 658.854 l
+ 192.366 665.883 l
+ 159.399 673.902 m
+ 159.399 651.303 l
+ 171.099 651.303 l
+ 171.099 673.902 l
+ 159.399 673.902 l
+ /CIEBasedDEFG /ColorSpaceFamily resourcestatus
+ {pop pop false} {true} ifelse
+ {[/DeviceCMYK]}
+ {[/CIEBasedDEFG 20 dict
+ dup /CreationDate (20001130011231) put
+ dup /RenderingIntent (RelativeColorimetric) put
+ dup /Description (Acrobat 5 Reader CMYK) put
+ dup /ColorSpace (CMYK) put
+ dup /Copyright (Copyright 2000 Adobe Systems, Inc.) put
+ dup /ProfileID <7FD780FF6943CB79EC9682CDA106A79A> put
+ dup /DecodeDEFG [
+ {{0 0.00731 0.0144 0.02113 0.02743 0.0333 0.03882 0.04406 0.04906 0.0539
+ 0.05863 0.06332 0.06801 0.07265 0.07721 0.08165 0.086 0.09034 0.09478 0.09931
+ 0.10391 0.1085 0.11304 0.11754 0.12206 0.12665 0.13125 0.1358 0.14021 0.14447
+ 0.14867 0.15291 0.15728 0.16181 0.1664 0.17095 0.17537 0.17964 0.18383 0.18807
+ 0.19244 0.19696 0.20155 0.2061 0.21052 0.21476 0.21887 0.22297 0.22715 0.2315
+ 0.23601 0.2406 0.24516 0.24959 0.25382 0.2579 0.26188 0.26583 0.26986 0.27402
+ 0.27836 0.28288 0.28746 0.29203 0.29646 0.3007 0.30479 0.30877 0.31272 0.31674
+ 0.3209 0.32523 0.32974 0.33432 0.33889 0.34333 0.34758 0.35167 0.35565 0.35957
+ 0.36348 0.36739 0.37133 0.37534 0.37949 0.38381 0.38831 0.3929 0.39746 0.40191
+ 0.40618 0.41027 0.41426 0.41818 0.42209 0.426 0.4299 0.43381 0.43771 0.44162
+ 0.44553 0.44943 0.45334 0.45725 0.46115 0.46506 0.46896 0.47287 0.47678 0.48068
+ 0.48459 0.4885 0.4924 0.49631 0.50021 0.50412 0.50803 0.51193 0.51584 0.51975
+ 0.52365 0.52756 0.53146 0.53537 0.53928 0.54318 0.54709 0.551 0.5549 0.55881
+ 0.56271 0.56662 0.57053 0.57441 0.57823 0.58192 0.58545 0.58879 0.59203 0.59526
+ 0.59859 0.60211 0.60579 0.6096 0.61348 0.61739 0.62129 0.6252 0.62909 0.63291
+ 0.63661 0.64015 0.6435 0.64674 0.64997 0.6533 0.6568 0.66047 0.66428 0.66815
+ 0.67206 0.67596 0.67985 0.68368 0.68739 0.69094 0.6943 0.69755 0.70078 0.70409
+ 0.70758 0.71125 0.71505 0.71892 0.72283 0.72672 0.73055 0.73427 0.73783 0.74119
+ 0.74444 0.74767 0.75098 0.75446 0.75812 0.76191 0.76578 0.76968 0.77358 0.77741
+ 0.78114 0.78471 0.78809 0.79134 0.79456 0.79786 0.80133 0.80499 0.80877 0.81263
+ 0.81646 0.8202 0.82377 0.82716 0.83041 0.83364 0.83693 0.84039 0.84404 0.84781
+ 0.85161 0.85535 0.85893 0.86232 0.86558 0.8688 0.8721 0.87554 0.87912 0.88273
+ 0.88628 0.88967 0.89293 0.89615 0.89943 0.90282 0.90629 0.90975 0.91311 0.91637
+ 0.91959 0.92281 0.9261 0.92942 0.93269 0.93591 0.93912 0.94234 0.94563 0.94895
+ 0.95222 0.95544 0.95865 0.96187 0.96516 0.96848 0.97174 0.97491 0.97798 0.98095
+ 0.98384 0.98667 0.98945 0.99214 0.99478 0.99741 1}
+ dup 3 -1 roll 0 1 3 copy 3 -1 roll exch ge
+ {pop pop pop pop pop 256 get}
+ {pop 3 copy pop le {pop pop pop pop 0 get}
+ {exch dup 4 -1 roll exch sub 3 1 roll sub div 256 mul dup
+ floor dup 3 1 roll sub exch cvi dup 1 add 4 -1 roll exch
+ get 4 -1 roll 3 -1 roll get dup 4 1 roll sub mul add}
+ ifelse} ifelse
+ } bind
+ {{0 0.00654 0.01284 0.01878 0.0243 0.02939 0.03414 0.03859 0.0428 0.04686
+ 0.05082 0.05473 0.05864 0.06255 0.06645 0.07036 0.07426 0.07817 0.08208 0.08598
+ 0.08989 0.0938 0.0977 0.10161 0.10551 0.10942 0.11333 0.11723 0.12114 0.12505
+ 0.12895 0.13286 0.13676 0.14062 0.1444 0.14804 0.15149 0.15478 0.158 0.16126
+ 0.16465 0.16824 0.17198 0.17582 0.17972 0.18362 0.18753 0.19144 0.19534 0.19925
+ 0.20316 0.20706 0.21097 0.21487 0.21878 0.22269 0.22659 0.2305 0.23441 0.23831
+ 0.24222 0.24612 0.25003 0.25394 0.25784 0.26175 0.26566 0.26956 0.27347 0.27737
+ 0.28128 0.28519 0.28909 0.293 0.29691 0.30081 0.30472 0.30866 0.31268 0.31683
+ 0.32115 0.32565 0.33024 0.33481 0.33925 0.34351 0.34761 0.35159 0.35551 0.35942
+ 0.36333 0.36723 0.37114 0.37505 0.37895 0.38286 0.38676 0.39067 0.39458 0.39848
+ 0.40239 0.40629 0.41017 0.41398 0.41766 0.42116 0.42449 0.42772 0.43095 0.43431
+ 0.43784 0.44154 0.44536 0.44925 0.45316 0.45706 0.46097 0.46487 0.46878 0.47269
+ 0.47659 0.4805 0.48441 0.48831 0.49222 0.49612 0.50003 0.50391 0.50773 0.51142
+ 0.51494 0.51828 0.52152 0.52475 0.52809 0.5316 0.53529 0.5391 0.54298 0.54689
+ 0.5508 0.55468 0.5585 0.5622 0.56573 0.56908 0.57232 0.57555 0.57888 0.58239
+ 0.58607 0.58987 0.59375 0.59766 0.60156 0.60545 0.60927 0.61298 0.61653 0.61988
+ 0.62313 0.62636 0.62967 0.63317 0.63684 0.64064 0.64452 0.64842 0.65233 0.65623
+ 0.66014 0.66405 0.66795 0.67186 0.67577 0.67967 0.68358 0.68748 0.69139 0.6953
+ 0.6992 0.70311 0.70702 0.71092 0.71483 0.71873 0.72264 0.72655 0.73045 0.73436
+ 0.73827 0.74217 0.74608 0.74998 0.75389 0.7578 0.7617 0.76561 0.76952 0.77342
+ 0.77733 0.78123 0.78514 0.78905 0.79295 0.79686 0.80077 0.80467 0.80858 0.81248
+ 0.81639 0.8203 0.8242 0.82811 0.83203 0.836 0.84007 0.84429 0.84871 0.85326
+ 0.85785 0.86238 0.86674 0.87092 0.87495 0.8789 0.88281 0.88672 0.89063 0.89453
+ 0.89844 0.90234 0.90625 0.91016 0.91406 0.91797 0.92188 0.92578 0.92969 0.93359
+ 0.9375 0.94141 0.94531 0.94922 0.95313 0.95703 0.96094 0.96484 0.96875 0.97266
+ 0.97656 0.98047 0.98438 0.98828 0.99219 0.99609 1}
+ dup 3 -1 roll 0 1 3 copy 3 -1 roll exch ge
+ {pop pop pop pop pop 256 get}
+ {pop 3 copy pop le {pop pop pop pop 0 get}
+ {exch dup 4 -1 roll exch sub 3 1 roll sub div 256 mul dup
+ floor dup 3 1 roll sub exch cvi dup 1 add 4 -1 roll exch
+ get 4 -1 roll 3 -1 roll get dup 4 1 roll sub mul add}
+ ifelse} ifelse
+ } bind
+ {{0 0.00678 0.01331 0.01942 0.02499 0.03003 0.03463 0.03889 0.04295 0.04691
+ 0.05083 0.05473 0.05864 0.06255 0.06645 0.07036 0.07426 0.07817 0.08208 0.08598
+ 0.08989 0.0938 0.0977 0.10161 0.10551 0.10942 0.11333 0.11723 0.12114 0.12505
+ 0.12895 0.13286 0.13676 0.14067 0.14458 0.14848 0.15234 0.15612 0.15976 0.16321
+ 0.1665 0.16973 0.17298 0.17638 0.17996 0.1837 0.18754 0.19144 0.19534 0.19925
+ 0.20316 0.20706 0.21097 0.21487 0.21878 0.22269 0.22659 0.2305 0.2344 0.23827
+ 0.24206 0.24571 0.24918 0.25248 0.25571 0.25896 0.26234 0.2659 0.26963 0.27347
+ 0.27736 0.28127 0.28517 0.28908 0.29298 0.29689 0.3008 0.3047 0.30861 0.31252
+ 0.31642 0.32033 0.32423 0.32814 0.33205 0.33595 0.33986 0.34377 0.34767 0.35158
+ 0.35548 0.35939 0.3633 0.3672 0.37111 0.37502 0.37892 0.38283 0.38673 0.39064
+ 0.39455 0.39845 0.40236 0.40627 0.41017 0.41408 0.41798 0.42189 0.4258 0.4297
+ 0.43361 0.43752 0.44142 0.44533 0.44923 0.45314 0.45705 0.46095 0.46486 0.46877
+ 0.47267 0.47658 0.48048 0.48439 0.4883 0.4922 0.49611 0.50002 0.50392 0.50783
+ 0.51173 0.51564 0.51952 0.52334 0.52704 0.53056 0.53391 0.53714 0.54037 0.54371
+ 0.54722 0.5509 0.55471 0.55859 0.5625 0.56641 0.57031 0.57422 0.57813 0.58203
+ 0.58594 0.58984 0.59375 0.59766 0.60156 0.60547 0.60938 0.61328 0.61719 0.62109
+ 0.625 0.62891 0.63281 0.63672 0.64063 0.64453 0.64844 0.65234 0.65625 0.66016
+ 0.66406 0.66797 0.67188 0.67578 0.67969 0.68361 0.68759 0.69168 0.69594 0.70038
+ 0.70495 0.70953 0.71404 0.71837 0.72254 0.72663 0.73075 0.735 0.73944 0.744
+ 0.74859 0.7531 0.75745 0.76168 0.76588 0.77015 0.77459 0.77915 0.78374 0.78826
+ 0.79268 0.79701 0.80137 0.80583 0.8104 0.81498 0.8195 0.82385 0.82802 0.83206
+ 0.83607 0.84015 0.84438 0.8488 0.85335 0.85794 0.86246 0.86682 0.871 0.87503
+ 0.87898 0.88289 0.8868 0.8907 0.89461 0.89851 0.90242 0.90633 0.91022 0.91407
+ 0.91782 0.92141 0.92482 0.92809 0.93131 0.93459 0.93803 0.94166 0.94543 0.94929
+ 0.95318 0.95703 0.96078 0.96439 0.96779 0.97101 0.97408 0.97705 0.97994 0.98277
+ 0.9855 0.98809 0.99057 0.99297 0.99531 0.99765 1}
+ dup 3 -1 roll 0 1 3 copy 3 -1 roll exch ge
+ {pop pop pop pop pop 256 get}
+ {pop 3 copy pop le {pop pop pop pop 0 get}
+ {exch dup 4 -1 roll exch sub 3 1 roll sub div 256 mul dup
+ floor dup 3 1 roll sub exch cvi dup 1 add 4 -1 roll exch
+ get 4 -1 roll 3 -1 roll get dup 4 1 roll sub mul add}
+ ifelse} ifelse
+ } bind
+ {{0 0.0064 0.01254 0.0183 0.02366 0.0287 0.03345 0.0379 0.04202 0.04575
+ 0.04918 0.05245 0.05573 0.05914 0.06275 0.0665 0.07035 0.0742 0.07797 0.08159
+ 0.08503 0.08831 0.09153 0.0948 0.09821 0.1018 0.10555 0.1094 0.1133 0.1172
+ 0.1211 0.12497 0.12874 0.13238 0.13583 0.13912 0.14234 0.1456 0.149 0.15258
+ 0.15632 0.16017 0.16406 0.16792 0.1717 0.17535 0.17881 0.1821 0.18532 0.18858
+ 0.19197 0.19555 0.19928 0.20312 0.20702 0.21092 0.21483 0.21869 0.22248 0.22613
+ 0.2296 0.2329 0.23613 0.23938 0.24276 0.24633 0.25005 0.25389 0.25778 0.26169
+ 0.26559 0.2695 0.27341 0.27731 0.28122 0.28512 0.289 0.29279 0.29645 0.29994
+ 0.30325 0.30648 0.30972 0.31309 0.31664 0.32036 0.32419 0.32808 0.33199 0.33589
+ 0.3398 0.3437 0.34761 0.35149 0.35529 0.35896 0.36246 0.36578 0.36901 0.37225
+ 0.3756 0.37915 0.38285 0.38668 0.39056 0.39447 0.39837 0.40226 0.40606 0.40974
+ 0.41325 0.41658 0.41981 0.42305 0.42639 0.42993 0.43363 0.43745 0.44133 0.44521
+ 0.44902 0.45271 0.45623 0.45956 0.4628 0.46603 0.46937 0.47289 0.47659 0.48038
+ 0.48417 0.48786 0.49139 0.49473 0.49796 0.5012 0.50453 0.50804 0.51171 0.51543
+ 0.51911 0.52264 0.52598 0.52922 0.53245 0.53578 0.53929 0.54297 0.54676 0.55056
+ 0.55426 0.5578 0.56115 0.56439 0.56762 0.57094 0.57444 0.5781 0.58182 0.58551
+ 0.58905 0.59241 0.59565 0.59888 0.6022 0.60569 0.60936 0.61316 0.61704 0.62094
+ 0.62483 0.62866 0.63238 0.63593 0.6393 0.64254 0.64577 0.64908 0.65257 0.65623
+ 0.66002 0.6639 0.6678 0.67171 0.67561 0.67952 0.68342 0.68733 0.69124 0.69514
+ 0.69905 0.70296 0.70686 0.71077 0.71467 0.71858 0.72249 0.72639 0.7303 0.73421
+ 0.73812 0.7421 0.74618 0.75041 0.75484 0.7594 0.76399 0.7685 0.77285 0.77702
+ 0.78105 0.78501 0.78898 0.79306 0.79729 0.8017 0.80626 0.81085 0.81537 0.81974
+ 0.82398 0.82818 0.83244 0.83686 0.84141 0.84601 0.85059 0.85512 0.85961 0.86415
+ 0.86876 0.87341 0.8781 0.88278 0.88752 0.89236 0.89731 0.9024 0.90757 0.91276
+ 0.91798 0.92319 0.92838 0.9336 0.93882 0.94401 0.94922 0.95444 0.95962 0.9648
+ 0.96992 0.97495 0.97994 0.98491 0.98989 0.99492 1}
+ dup 3 -1 roll 0 1 3 copy 3 -1 roll exch ge
+ {pop pop pop pop pop 256 get}
+ {pop 3 copy pop le {pop pop pop pop 0 get}
+ {exch dup 4 -1 roll exch sub 3 1 roll sub div 256 mul dup
+ floor dup 3 1 roll sub exch cvi dup 1 add 4 -1 roll exch
+ get 4 -1 roll 3 -1 roll get dup 4 1 roll sub mul add}
+ ifelse} ifelse
+ } bind
+ ] put
+ dup /Table [9 9 9 9 [
+ [
+ 
+ 
+ 
+ 
+ 
+ 
+ <92C57982C07972BA7962B57950B1793EAC7A2AAA7A0FAB7B008D8091C58182BF8072BA7F
+ 61B47F50B07F3EAB7F29A87F10AA80008D8091C48981BE8771B98661B38550AF843DAA84
+ 29A78410A885008D8091C39081BD8E71B88D60B38B4FAE8A3DA98A29A68A10A789008D80
+ 90C29881BC9671B79360B2924FAD903DA98F29A59010A68B008C8090C1A080BC9D70B69A
+ 60B1984FAC963DA89629A59610A58B008C808FC1A980BBA570B6A260B09F4FAC9D3CA79D
+ 29A49A10A48B008C808FC0B180BBAD70B5A960B0A64EABA43CA7A329A39C10A38B008C80
+ 8FC0BA80BAB570B5B060AFAD4EAAAB3DA6A829A39C11A38B008C80>
+ <85D17976CA7967C47857BF7847BA7935B57921B27A08B37B008A8084D08076C97F66C47F
+ 57BE7E46B87E35B47E21B17F08B180008A8084CF8875C88666C38557BD8446B78435B384
+ 21B08409AF84008A8084CD8F75C78D66C18B56BC8A46B68935B18921AE8A09AE86008A80
+ 84CD9775C69466C09256BB9046B58F35B08F21AD8F0AAC87008A8084CC9E75C69B66C099
+ 57BA9746B49535AF9522AC940AAB87008A8084CBA675C5A266BF9F57B99D46B39C35AF9C
+ 22AB970BAA87008A8084CBAE75C4A966BEA657B8A447B3A335AEA122AB970BA987008A80
+ 84CAB675C4B166BEAD57B8AA47B2A936ADA422AA970BA988008B80>
+ ][
+ 
+ 
+ 
+ 
+ 
+ <96B57486B17477AD7566A97554A57642A2772DA07812A27800898095B47C86B07C76AC7C
+ 66A87C54A47C41A17C2D9F7C12A17D00898095B38486AF8376AB8265A78253A38141A081
+ 2C9E81129F8200888094B28C85AE8B75AA8964A68853A287409F872C9D87129E87008880
+ 94B19584AD9274A99164A58F52A18E409E8D2C9C8D129D8B00878093B19D84AC9A74A898
+ 63A49652A1943F9D932B9B93129C8C00878093B0A683ACA273A89F63A49D51A09B3F9D99
+ 2B9A99129B8C00868092B0AE83ABAA73A7A762A3A4519FA23F9CA12B9A9D129A8C008680
+ 92AFB783ABB373A7AF62A3AB519FA93F9CA72B999D129A8C008680>
+ <88C0737ABB746BB6745BB2754BAE7639AA7624A8770AAA7700868088BF7B7ABA7B6BB57B
+ 5BB17B4AAC7B38A97B24A77C0BA87C00868088BE8379B9826AB4815BB0814AAB8038A880
+ 24A6810BA78100858088BD8B79B8896AB3885AAF874AAA8638A78624A4860BA585008580
+ 87BC9279B7906AB28F5AAE8D49A98C38A68C24A38C0BA48800858087BB9A78B69869B296
+ 59AD9449A99237A59224A2920BA38800858087BBA278B69F69B19D59AC9A49A89937A499
+ 24A2970CA28800858086BAAB78B5A769B0A459ACA149A7A037A49F24A1980CA188008480
+ 86BAB378B5AF69B0AC59ABA949A7A737A3A424A0980CA088008480>
+ <7BCB736EC6735FC07450BC7441B7752FB3751BB27503B0780083807BCA7B6EC57A5FBF7A
+ 50BA7A41B67A2FB27A1BB07A04AE7C0083807BC9826EC4815FBE8050B98040B47F2FB07F
+ 1BAF8005AC800083807BC8896DC2885FBD8650B88640B3852FAF851CAD8605AB83008380
+ 7BC7906DC18E5FBC8D50B78C40B28B2FAE8B1CAC8B06A9840083807BC6986DC1965FBB94
+ 50B69240B1912FAD911CAB9006A8840083807BC69F6DC09D5FBA9A50B59840B0972FAC97
+ 1CAA9306A7840083807BC5A76DBFA45FBAA150B49F40AF9E30AB9D1CA99307A684008380
+ 7BC5AF6DBFAC5FB9A850B4A641AFA530ABA01DA89307A585008380>
+ ][
+ 
+ 
+ 
+ 
+ <9AA56F8BA2707B9F716A9C72599A7345987430967516987500867E9AA4778BA1787B9E78
+ 6A9B7858997945977930957A16977A00858099A3808A9F7F7A9D7F699A7F57977F44957F
+ 2F947F15957F00848098A188899E87799C866899865796854494842F9384159485008380
+ 97A091889D8F789B8E67988C56968B43938A2E928A15938900828097A09A889D97789A95
+ 6797935595924293902E919015928D008280969FA3879CA077999D66979A559498429297
+ 2E909714918E008180969FAC879CA87799A56696A254949F42929E2D909C14918E008180
+ 959EB5869BB17698AD6596AA5493A74191A52D8F9E14908E008180>
+ <8DAF6E7EAB6F6FA8705FA5714FA2723C9F73289E740DA1740082808CAE767EAA776FA777
+ 5FA4774EA1783C9E79289D790D9F790082808CAD7E7DA97E6EA67E5FA27E4E9F7E3B9D7E
+ 279B7E0D9D7E0081808BAC867DA8856EA5855EA1844D9E843B9C83279A830D9C83008180
+ 8BAB8F7CA78D6DA48C5DA08B4D9D8A3B9B892799890D9A870080808AAA977CA7956DA393
+ 5DA0914C9D903A9A8F26988F0D99890080808AAA9F7BA69D6CA29A5C9F984C9C963A9996
+ 2697950D988900808089A9A87BA6A56CA2A25C9E9F4B9B9D3A999D2697990D9789008080
+ 89A9B17BA5AD6CA2AA5C9EA74B9BA53998A326969A0D9789008080>
+ <7FBA6D72B66E64B26F55AE7045AA7233A8721FA77306A7730080807FB97572B57664B176
+ 55AD7644A97733A6771FA57806A5790080807FB87D71B47D63AF7C54AB7C44A87C33A57D
+ 1FA47D06A37E0080807FB78571B28463AE8354AA8244A78232A4821FA28207A182008080
+ 7EB68C71B18B62AD8A53A98943A68832A3881FA18807A0850080807EB59470B19262AC91
+ 53A88F43A58E32A28E1FA08E079F850080807EB49C70B09A62AC9853A89643A49532A194
+ 1E9F93079D850080807DB4A470B0A162AB9F53A79D43A39B32A09B1E9E95079C85008080
+ 7DB4AC70AFA962ABA652A7A443A3A332A0A01E9E95089C85008080>
+ <73C56D66C16E58BC6F4AB8703AB47129B17115B27100AB7400808073C47466C07558BB75
+ 4AB7753BB2762AAF7615B07600AA7900808073C37C66BE7B58BA7B4AB57B3BB17B2AAE7B
+ 15AE7B01A87D00808073C28366BD8258B8814AB4813AB0812AAD8116AC8101A681008080
+ 72C18A65BC8958B78849B3873AAE862AAB8616AB8702A48100808072C09165BB9058B68E
+ 49B28D3AAD8C2AAA8D16A98C02A38100808072BF9965BA9758B59549B1943AAD932AA993
+ 16A88F02A28200808072BFA065BA9E58B59C49B09A3AAC9A2AA89817A78F03A182008080
+ 72BEA865B9A658B4A349AFA13AABA02AA89C17A78F03A082008080>
+ ][
+ 
+ 
+ 
+ <9F956990936B80916D6F906E5D8F70498E71348D731A8F7300837B9E94728F92737F9074
+ 6E8F755C8D76488C77338C78198D7800827E9D927B8E907B7E8F7C6D8D7C5B8C7C488B7C
+ 328A7D188B7C0080809C91848D8F847D8D836C8C835A8B82478A82328982188A82008080
+ 9B908D8C8E8C7C8C8B6B8B8A598A894689883188871889870080809A8F968B8D957B8B93
+ 6A8A9158898F45888E31878D17888C0080809A8EA08B8C9D7A8B9B698998588896458794
+ 308694178790008080998DA98A8CA67A8AA36989A057889D44879B30869A17868F008080
+ 998DB28A8BAF798AAB6888A85787A54486A330859F16858F008080>
+ <919F69839C6B749A6C64986E53966F4095712B947210977100807E909E71829B72739973
+ 6397745295753F93762B9276109576008080909C7A819A7A72977A62957B51937B3F927B
+ 2A917B10937B0080808F9B828198827296816294815092813E91812A9081109281008080
+ 8E9A8B80978A7195896193885091873E9086298F861090850080808D99937F9692709490
+ 60928F4F908D3D8F8C298E8C108F8A0080808D989C7F969A7094985F91964F8F943D8E93
+ 298D930F8E8A0080808C98A57E95A26F93A05F919D4E8F9B3C8D9A288C980F8D8A008080
+ 8C97AE7E95AB6F93A85F90A54E8EA23C8DA1288C9B0F8C8A008080>
+ <84A96876A66A68A36B59A06D499E6E379C70229C70089E7000808083A87076A57168A272
+ 599F73489D74369B75229A75089B7500808083A77875A47967A179589E79489B7A36997A
+ 22997A09997B00808082A58075A280669F80579D80479A7F36987F22977F099880008080
+ 81A48874A187669E87579B8647998535978521968509968400808081A39073A08F659D8E
+ 569B8D46988C35968B21958B09948600808080A39973A097659D95569A93469792349591
+ 21949109938600808080A2A1739F9F649C9C55999A459799349598219395099286008080
+ 80A2A9729FA7649CA45599A24596A034949E219396099186008080>
+ <77B4676AB0695CAD6B4EAA6C3FA76D2DA56E19A66E02A37000808076B36F6AAF705CAC71
+ 4EA8723EA5732DA37319A47302A07500808076B17769AE775CAA774EA7783EA4782DA279
+ 19A278029E7A00808076B07E69AC7E5BA97E4DA67E3EA37E2DA07E19A07E039C7F008080
+ 75AF8668AB855BA8854DA4843DA1842D9F83199F84039A8200808075AE8E68AA8C5BA78B
+ 4CA38A3DA08A2C9E89199E8A03998200808075AD9568AA945AA6924CA3913DA0902C9D90
+ 199D8E03978200808074AD9D68A99B5AA6994CA2983D9F972C9D96199C91049682008080
+ 74ACA568A9A35AA5A14CA19F3C9E9E2C9C9C199B91049682008080>
+ <6ABF675EBB6851B86943B46B34B16C23AF6D0EB16C009F740080806ABE6E5EBA6F51B670
+ 43B27034AF7123AD720FAF71009E780080806ABD755EB97651B57643B17634AE7624AC77
+ 0FAD76009D7C0080806ABB7C5DB77C51B37C43AF7C34AC7C24AA7C0FAB7C009B80008080
+ 69BA835DB68350B28243AE8234AB8224A98210A982009A8000808069B98B5DB58A50B189
+ 43AD8834AA8824A78810A887009A8000808069B8925DB49150B09043AC8E34A98E24A68E
+ 10A68B00998000808069B8995DB49850AF9643AB9534A89524A59410A58B009880008080
+ 69B8A15DB39F50AF9D43AB9C34A79B24A59810A58B009880008080>
+ ][
+ 
+ 
+ 
+ <958F64878E66788C68688C6A568B6C438A6E2E8A6F148D6F00807A948D6C868C6E778B6F
+ 678A715589724389732E8874138A7400807E938B75858A76768977668877548878428779
+ 2D8779138879008080928A7E84897E75887E65877E54867E41867E2D857E13877E008080
+ 9188878387867486866486855385854184842C848412858400808090879082868F73858D
+ 63858C52848B40838A2C838A1283880080809086998285977385956284935183923F8290
+ 2B829012828C0080808F86A28185A072849D62839B5182983F82972B819612818C008080
+ 8F85AB8184A87183A56182A25082A03E819E2B819B11808C008080>
+ <8799637A97656C95675D93694C926B3A916D26916E0B946D00807D87976C7A956D6C936E
+ 5C92704C90713A9072258F730B91720080808695747994756B92755B90764B8F77398E77
+ 258E780B8F7700808085947C78927C6A907C5B8F7D4A8E7D398D7D258C7D0B8D7D008080
+ 849284779184698F845A8E834A8C83388B83248B820B8B8200808084918D76908C688E8B
+ 598D8A498B89388A88248A880B8986008080839095768F94688D92598C91488A8F37898F
+ 24898F0B888700808083909E758E9C678D9A588B98488A963789952388940B8787008080
+ 828FA7758EA4678CA2588A9F48899D36889C2387980B8687008080>
+ <7BA3626EA065619E67529C69429A6A31996C1D9A6C04996D0080807AA16A6E9F6C609C6D
+ 529A6F4299703197711C987104967200808079A0726D9D73609B74519975429775309676
+ 1C9676049477008080799E7A6C9C7A5F997B50977B41967B30947B1C947B04927C008080
+ 789D826C9A825E98815096814094812F93811C9381059081008080789C8A6B99895E9788
+ 4F95884093872F92871C9287058E83008080779B926A99915D96904F948E3F928D2F918D
+ 1C908D058D83008080779A9A6A98995D96974E93953F91942E90941B9091058C83008080
+ 769AA26A98A05D959E4E939C3F919B2E8F9A1B8F92058B83008080>
+ <6EAD6262AA6455A86647A56738A36927A26A12A46A00996E0080806EAC6962A96B55A66C
+ 47A46D38A16E27A06F12A26F0097730080806DAB7161A87155A57247A27338A074279E74
+ 13A0740096780080806DA97861A67854A37946A079389E79279D79139E7900947C008080
+ 6CA87F60A57F54A27F469F7F379D7F279B7F139D7F0093800080806CA78760A48653A186
+ 469E85379C85269A85139B850092800080806BA68E60A38E53A08D459D8C379B8B26998B
+ 139A8A0091800080806BA5965FA295539F94459C92369A9226989213998D009080008080
+ 6BA59E5FA29D539F9B459C9936999926979713988D009080008080>
+ <62B86156B5624AB3643CB0662EAE671DAD6808AF6700937300808061B86856B4694AB16A
+ 3CAE6B2EAC6C1DAB6D09AC6C00927700808061B66F55B37049AF703CAC712EAA721DA972
+ 09AA7200917C00808061B47655B17649AE763CAB772EA8771DA7770AA77700907F008080
+ 60B37D55B07D49AC7D3CA97D2EA77D1DA67D0AA67D008F8000808060B28455AF8449AB83
+ 3CA8832DA5831DA4830AA482008E8000808060B18B55AE8A49AA8A3CA7892DA4891DA389
+ 0AA287008D8000808060B09255AD9149A9903CA6902DA38F1DA28F0AA187008D80008080
+ 60B09A55AC9949A9983CA5972DA2961DA1930BA087008C80008080>
+ ][
+ 
+ 
+ <98805E8A7F617B7F646B806659806946806B31816D17826D008076977D68897D6A7A7D6C
+ 6A7E6D587E6F457E71307F7216807200807A967B71887B72797B73687C74577C75447C76
+ 307D77167D7700807E95797A87797A787A7B677A7B567A7C437B7C2F7B7C157B7C008080
+ 9477838677837778836678825579824379822E7A8115798100808093768C85768C76778B
+ 65778A5477894278882E788715788700808092759684759475759265769153768F41778E
+ 2D778D14768B00808091749F83749D74759A6475985376964176942D769414758D008080
+ 9173A88374A67374A36374A052759D40759B2C759A14758D008080>
+ <8B885E7E88617087636087664F86683D866A29876C0E896B00807A8A86677D86696F856B
+ 5F856C4F856E3D84702885710E867000807D89846F7C84716E83725E83734E83743C8375
+ 2883760E84750080808882787B82796D81795E817A4D817A3B817B27817B0D827A008080
+ 8780817A80816C80815D80804C7F803B7F802780800D8080008080867F89797F896B7F88
+ 5C7E874C7E873A7E86267E860D7E85008080867E92787E916A7E905B7D8E4B7D8D397D8C
+ 267D8C0D7D89008080857D9B787D996A7D975A7C954A7C94397C93267C920D7C89008080
+ 857CA4777CA2697C9F5A7C9D4A7C9B387B9A257B970D7B88008080>
+ <7E925D729160648F63568F65468E67348D69208E6A068F6A00807D7D9066718F68648E69
+ 558D6B458C6D348B6E208C6F068C6F0080807D8E6E708D6F638C70548B72458A73338A74
+ 1F8A74068A740080807C8C766F8B77628A775489784488783388791F887906887A008080
+ 7B8A7E6E897E61887E53887E43877E32867E1F877E07867F0080807A89866E8886608786
+ 5286854385843285841E85840784830080807A888F6D878E60868D51858C42848B31848A
+ 1E848B0783840080807987976D86965F85945184924284913183911E8390078284008080
+ 79879F6C869E5F859C51849A4183983182981E8294068184008080>
+ <729C5D669A5F5998624B97643C96662B956816986800936A00807F719A65659866599768
+ 4B956A3C946C2B936D16956D00916F00808070986C65966E58956F4A93703B92712A9272
+ 169372008E740080807096746495755793754A92763B90772A9077169177018C79008080
+ 6F957C63937C56927C49907C3A8F7C298E7C168F7C018B7E0080806E9383629283569083
+ 488F833A8E82298D82158D820189810080806E928B62918B558F8A488E89398C88298C88
+ 158C880188810080806D9293629092558E91478D90398B8F288B8F158B8D018781008080
+ 6D919B618F9A558E98478C97388B96288A95158A8E018681008080>
+ <65A65C5AA45E4EA26041A063329F64219F660CA265008E6E00808065A5635AA3654EA067
+ 409E68329D6A219D6B0C9F6A008C7300808064A36A59A16C4D9F6D409D6E319B6F219B70
+ 0C9C6F008A7800808064A172589F724C9D733F9B743199752199750D9A7400897C008080
+ 639F79589D794C9B7A3F997A31987A20977A0D987A008880008080639E80579C804B9A80
+ 3E98803096802096800D9680008780008080629D88579B874B99873E9786309586209486
+ 0D9485008680008080629C8F579A8F4B988E3E968D30948C20938D0D9388008580008080
+ 629C97579A964B97953E95943093932092920D9289008580008080>
+ <59B25A4EAF5D42AD5F36AB6127AA6216AB6203AA6300897200808058B0614EAE6342AB65
+ 35A96627A86716A96704A76800887700808058AF684DAC6A42AA6B35A76C27A66D16A66C
+ 04A46D00867B00808058AD6F4DAA7041A87135A57127A47216A47205A17300857F008080
+ 57AB764DA97741A67735A47727A27716A277059F7900848000808057AA7D4CA77D41A57D
+ 34A27D27A07D16A17D059D7E00838000808057A9844CA68441A38434A183269F83169F84
+ 059B8200838000808057A88B4CA58B41A38A34A08A269E8A169E89059A84008280008080
+ 56A7924CA49241A291349F91269D91169D8E059884008180008080>
+ ][
+ 
+ <9B71598D725C7D73606D74635B756548766833776A19786B0080729A6E638C6F657C7067
+ 6C726A5A736C47746E32756F197570008077996B6C8A6C6E7B6E6F6B6F71597172467273
+ 32737418727500807B976876896A767A6B77696D78586E7945707931717A18707A00807E
+ 96667F87687F78697F686B7F576D7F446E7F306F7F176E7F008080946489866688776887
+ 676987566B86436C85306D85176C8500808094629285649176668F66688E556A8C436B8B
+ 2F6B8B176B8A00808093619C85639A766597656795546893426A922F6A91166A8E008080
+ 9260A58462A27564A065669D54679A4269982E699716698F008080>
+ <8E795981795C737A5F637B62527B65407C672B7D69117E690080768D7662807764727767
+ 62786951796B3F7A6D2B7A6E117C6E00807A8C736B7F746C70756E6176705077713E7772
+ 2A787310797300807E8B71747D72756F73766074774F74773D75782A7678107778008080
+ 8A6E7D7C707D6E717D5F727D4E737E3D737E29747E10757E008080896D867B6E856D6F85
+ 5E70854D71843C72842872830F7483008080886B8F7A6C8E6C6E8D5D6F8C4D708A3B708A
+ 2870890F7287008080876A987A6B966C6C955C6E934C6F913B6F90276F900F718A008080
+ 8769A1796A9F6B6C9C5C6D9A4C6E983A6E97276E950F718A008080>
+ <82825875815C68815F598161498264378266238368098568008079817F61747F63677F66
+ 587F68487F6A36806C22816D09826D00807D807C69737C6B667D6D577D6E477D70367E71
+ 227E720980720080807F7A72727A73657A74567B75467B76357C77217C77097D77008080
+ 7E787A71787B64787B55797C46797C357A7C217A7C097C7D0080807D7683707683637783
+ 547782457882347882217882097A810080807C748B6F758B62768A547689447688337788
+ 2076880879850080807B73946F749361749153759044758F33758E20758E087886008080
+ 7B729C6E739B617499537497437496327495207493087786008080>
+ <758B586A8A5B5D895E4F89613F89632E8965198B66028A6700807C7488606988625C8765
+ 4E87673F87692E876A19886B02876C00808073866868856A5B856B4D856D3E846E2D856F
+ 1986700285710080807283706783715A83724C83733D82742C8375198375028377008080
+ 7181786681795981794B817A3D817A2C817A18817A02817C008080718080657F80587F80
+ 4B7F803C7F802C7F80187F80038080008080707E88647E88587E874A7E873B7E862B7D86
+ 187D86037E820080806F7D90647D8F577D8E4A7D8D3B7C8C2B7C8C187C8B037D82008080
+ 6F7C98637C97577C96497C943B7C932A7B93177A90037D82008080>
+ <6994575E935A52925D44925F3591622492630F956300886A00807F68925F5D9161519063
+ 448F65358F67248F680F916800866E0080806790665C8F68508E6A438D6B358D6D248D6D
+ 0F8F6D008474008080668D6E5B8D6F4F8C70428B71348B72238B730F8C72008379008080
+ 668B755B8B764F8A774289773389782389780F897800817D008080658A7D5A897D4E887D
+ 41887E33877E23877E0F877E0080800080806489855988844D8784408684328684228584
+ 0F858300808000808064878C59878C4D868B40858A32848A22848A0F8488008080008080
+ 6387945986934D85924084913283902283900F828A008080008080>
+ <5D9F56529D59479C5B3A9B5E2C9A601A9C61079C6100846D0080805C9D5D529B5F469A61
+ 3A99632B98651A99660799660082720080805B9B645199664698683997692B966A1A976B
+ 07966B0081770080805B986B50976D45966E38946F2A94701A947007937000807B008080
+ 5A96735095734494743892752A92751A927507907600807F00808059957A4F937A44927B
+ 37917B2A907B19907B078E7C0080800080805993814F9281439181379081298F81198F81
+ 078C810080800080805992884E9188439088378F87298D87198D87078B85008080008080
+ 5892904E9090438F8F368E8E298C8E198C8D078985008080008080>
+ <51AA5446A9573BA7592FA65B21A65D0FA95D00A06000807100808050A95B46A75D3BA55F
+ 2FA46120A3620FA662009D650080760080804FA66245A5643AA3652EA16620A1670FA367
+ 009B6A00807A0080804FA46945A26A3AA16B2E9F6C209F6D0FA06C00986F00807E008080
+ 4EA26F44A070399F712D9D72209D720F9E720096750080800080804EA076449F77399D77
+ 2D9C781F9B780F9C7700947A0080800080804D9F7D439E7E399C7E2D9A7E1F997E0F9A7E
+ 01927F0080800080804D9E84439C84399B842D99841F98840F9883019180008080008080
+ 4D9D8C439C8C389A8B2D988B1F978B0F9788018F81008080008080>
+ ][
+ <9E62548F64577F675B6E695F5C6B62496D65356E681C6E6A00806E9C5E5D8D61607E6363
+ 6D65665C6868496A6B346B6D1B6A6E0080739A5A678C5D697C606B6C626D5A656F476771
+ 3368721B68730080789857718A5A727B5D746A60755962764664773266771A657800807C
+ 97547B88577B795A7C695D7C58607C46627D32637D1A637D00807F955285875584785884
+ 685B84575E83456083316183196283008080944F8E86538D77568C67598B565C8A445E89
+ 315F88196088008080944E98855196775594675892565B91445D8F305D8E195F8D008080
+ 934CA285509F76549C66579A555A97435C96305C95185E90008080>
+ <916A53846B57756D5B656F5E5470614272652D736714746800807290665D826860746A63
+ 646B65536D68416F6A2D706C13716C0080778E626681646873676A63696C526A6E406C70
+ 2C6D71136E7100807B8D5F6F7F61717164726266735168743F69752B6A76136C7600807E
+ 8B5C797E5F7970617A60637A50657B3E677B2B677C126A7B0080808A5A827D5C826F5F82
+ 5F61824F63813E65812A658112698100808089588B7C5A8B6E5D8A5F5F894E62883D6387
+ 2A63871268860080808856957B59936D5C925E5E904E608E3C628D29618D12678A008080
+ 88559E7B589C6D5A995D5D974D5F953C619429609311668C008080>
+ <8572537873576B745A5C755E4B76613A77642678660C7B66008076846E5C776F5F6A7162
+ 5B72644B736739746925756B0C786B00807A826A65766C67686E695A6F6B4A706D38716F
+ 2572700B767000807D81676E74696F676B71596C72496E73376F74246F750B7375008080
+ 806477736677666878576A79486B79376C7A236C7A0B727A0080807F627F726480656680
+ 566880476980366A80236A800B70800080807E6088716288646487566687466886356986
+ 2368860B6F840080807D5F9171619063638F55658D46668C35678C22668C0B6E87008080
+ 7D5D9A7060986362965563944565933466922264910A6E87008080>
+ <797A536D7A57607B5A527C5D427C60317D631D7E6405816500807978765B6C775E5F7861
+ 517964427966307A681D7B69057E6A00807D7673646B74665E756850766A41776C30776D
+ 1C786E057C6F00808075706C69716D5D726F4F73704074722F75731C7573057A74008080
+ 746D74686F755C70764E71773F72782F72781B727805787A008080736B7D676D7D5B6E7D
+ 4D6F7D3E707E2E707E1B707E05787F008080726985676B855A6C854C6D843E6E842D6E84
+ 1B6E8405788300808072688D66698D596B8C4C6C8B3D6D8A2D6D8A1A6C8A057883008080
+ 7166966668955969934B6B923D6B902D6C901A6B8F047983008080>
+ <6D835262835655835948835C39845F28846113876200836600807C6C805A61805D548060
+ 47806238816527816613836600816A00807F6B7C625F7D64537D66467E68387E6A277F6B
+ 13806B00806F00808069796A5E7A6C527B6D457B6F377B70267C71127D70008075008080
+ 6877725D7873517874447975367976267976127A7600807A00808067757A5C757A51767B
+ 44777B35777B25777C12787B00807E0080806773825C7482507482437582357581257581
+ 12768200808000808066718A5B72894F7389437388347488247488117487008080008080
+ 6670925B71914F729042728F34728E24728E11738B008080008080>
+ <618C52568C554A8C583E8C5B2F8C5D1E8D5F098E5F00806900807E60895955895C4A895E
+ 3D89612F89631E8A640A8B6400806E0080805F86605486634986653C86672E86681D8769
+ 0A87690080730080805E836853836948836B3B836C2D846E1D846E0A846E008078008080
+ 5D816F5281704781723B81722D81731C827309827400807D0080805C7F77527F78467F78
+ 3A7F792C7F791C7F7909807A0080800080805B7D7E517D7F467D7F397D7F2C7D7F1C7D7F
+ 0A7E7F0080800080805B7B86507C86457C85397C852B7C851C7B85097C84008080008080
+ 5A7A8D507B8D457B8C397B8C2B7A8B1B7A8B097B86008080008080>
+ <5597504B965340955633955925955B13985C02955E00806D0080805494574A935A3F935C
+ 33925F24936013956102916200807200808053915E4990603E9062329064249066139266
+ 028E67008077008080528E65488E673D8D69318D6A238D6B128F6B028B6D00807B008080
+ 518C6C478B6E3C8B6F308B70238B70128C7002887200807F008080518A734789743C8975
+ 30897622887612897602867800808000808050887B46887B3B877B2F877C22877C12877C
+ 02857D0080800080804F86824686823B86822F8582228582118582028381008080008080
+ 4F85894585893B85892F8488228488128387038282008080008080>
+ <48A24E3FA15134A05428A0561AA15809A35800926000807000808047A0553E9F57339E5A
+ 289E5C199F5D099F5D008F64008075008080479D5C3D9C5E339B60279B61199C62099C62
+ 008C6900807A008080469A623D9964329965269867189967089867008A6E00807D008080
+ 4598693C976A31966B26966C18966C08956D0088740080800080804596703B9571319471
+ 2594721894720992720086790080800080804494773B9377319378259278179278099079
+ 00857E00808000808044927E3A927E30917E25917E17907E088E7E008380008080008080
+ 4391853A9185309085258F84178F85098C83008280008080008080>
+ ][<9F544E905752805A566F5D5A5E605E4B63623664661E6468017D6B9D4F588E525B7F565F
+ 6E59625C5C654A5F6836616B1E606C027D709B4A628C4E657D52676D55695B596C495C6E
+ 355D701D5D71027D7599456C8A4A6E7B4E706B52715A5573475874345A751C5B76027D7A
+ 9741768946777A4A786A4F7959527947557A33567B1C597B027D7E953E80874380794880
+ 694C805850804653803354801C5781027D81943B8A86408A784589684A88574E87455186
+ 3251861B5687027D81933894853E9277439167488F574C8E454F8D324F8C1B558C027D81
+ 92369E853C9B764199674696564A94454D93324D921B5490027D81>
+ <945B4E855D5276605666635A56655E4367622F686517696600806E91565884595B755C5E
+ 655F615561644363672F646A16666B008073905161825464745866645B69535E6B41606D
+ 2E616F1664700080778E4D6B80506D72546E635770525A71405D732D5D7415627400807B
+ 8C49757F4D75715176615477515778405A792C5A7915607A00807F8B457E7E4A7E6F4E7E
+ 60517F50557F3F577F2C577F155E7F0080808A42887C47876F4B86604F865052853E5585
+ 2C5485145E850080808940917C45906E498E5F4D8D4F518C3E538B2B528B145E8A008080
+ 883E9A7B43986D48965F4C944F4F923E51912B5191145E8D008080>
+ <88624E7B64526D66565E685A4D6A5E3C6C61286D640F7164008072865D5779605A6B625E
+ 5C64614C66643B68662769690E6E69008076845860785B636A5E655B61684B636A3A656C
+ 27656E0E6C6E00807B83546976576B695A6D5A5D6F4A60703961722661730E697300807E
+ 815073755474675775595A76495D77385E77255E780D6978008080804D7C74517C66547C
+ 58577D485A7D385C7D255B7E0D697E0080807F4A85734E84655284575584485883375983
+ 2559830D6A830080807E488E724C8D65508C56538B47568A3757892457890D6A87008080
+ 7E4696714A95644E9356519147549036558F24558F0D6A89008080>
+ <7D694E706B52636D56546E5A45705D3471602072620778630080767B65576F675A62695D
+ 536A60446C63336D651F6D6707756800807A79605F6D6362606564526767436969326A6B
+ 1F696C07746D00807D785C686C5F6A5F616C51636D42656F3166701E6671077472008080
+ 7659706A5B725E5E735060744162753163761E637607747800808075557969587A5D5B7A
+ 4F5E7B40607B30607C1D617C07747D0080807453826856825C59824E5B81405D812F5E81
+ 1D5E8207748100808073508A68548A5B57894E59883F5B882F5B871D5D88077485008080
+ 734E936752925B55904D588F3F598E2F5A8D1C5C8D077584008080>
+ <71714E6573525874554B75593C765C2B775F177860017F620080796F6D56646E5957705C
+ 4A715F3B72622A7364167465017F6700807D6E695E626A61566C63496E653A6F682A7069
+ 16706A017F6C0080806C656661676855696A486A6C396C6D296C6F156D6F017E72008080
+ 6B616E606370546571476772396873286974156B74017E770080806A5E775F6077536378
+ 466479386679286679156979017E7C008080695B7F5E5E7F52607F45627F37637F27637F
+ 14677F017E800080806859875D5C87515E86456086376185276085146585017E81008080
+ 68578F5D5A8E515C8D445E8C365F8B265E8C14648A017E81008080>
+ <657A4D5A7B514E7C55417C58327D5B227E5D0D815D00806600807C6376555977584D785B
+ 40795E327A60217A620D7D6200806A00807F62725D57735F4C74623F7564317666217667
+ 0C796700806F008080616E64566F664B71683E726A30726B20736C0C766C008075008080
+ 606A6C556C6D4A6D6F3D6F702F6F711F6F720C747100807A0080805E6774546975496B75
+ 3C6C762F6C771F6C770C727700807E0080805E657B53677C48687C3C697C2E6A7D1E697D
+ 0C707D0080800080805D62835364834766833B67832E68831E67830C6E82008080008080
+ 5C608B52638B47648A3B66892D66891E65890B6D87008080008080>
+ <59834C4F845044845337855629865917885A04885C00806900807E577F534E8057428059
+ 36815C28825E17835F05846000806E008080567B5B4C7C5D417D60357D62277E64167F64
+ 0581650080730080805578624B7964407966347A68277A69167B69047E6A008078008080
+ 5474694A756B3F766C33776D26776E15786E047B7000807C0080805371714972723F7373
+ 337473257474157574047976008080008080526E784870793E717932727925727A157279
+ 05787B008080008080526C7F486E803D6F80327080246F80147080047980008080008080
+ 516A87476C873D6D86316E86246D86146F86047983008080008080>
+ <4D8E4B438D4E398E512D8E541E8F560C9257008A5C00806D0080804C8A52428A55388A57
+ 2C8A5A1E8C5B0C8D5C0086610080720080804B865841865B37875D2B875F1D88610C8961
+ 0083660080770080804A825F4083613683632A84651C84660C856600816B00807B008080
+ 497F663F806835806929806A1C816B0B816B00807000807F008080487C6D3E7D6E347D6F
+ 287D701B7E700B7F710080760080800080804779743E7A75337B76287B761A7B760B7C76
+ 00807B00808000808046777B3D787C33797C27797C1A797C0A7A7D00807F008080008080
+ 4675833D76833277832777821A76820B7982008080008080008080>
+ <41994938994C2E994F229951129C52039A540085600080700080803F964F3696522C9654
+ 2096561199570395590082640080750080803E92553592582B925A1F935C11955C03915E
+ 0080690080790080803D8E5C348F5E2A8F601E8F61109161038D6300806E00807D008080
+ 3D8B63338B64298C651E8C66108D66038A690080740080800080803C886933896B29896B
+ 1D896C0F8A6C03876E0080790080800080803B85703286712886711D87720F8772038574
+ 00807E0080800080803A83773184772784781C85780F847802837A008080008080008080
+ 3A817E31827E27837E1C837E0F827E03827F008080008080008080>
+ ]]] put
+ dup /DecodeABC [
+ {0 pop} bind
+ {{0 0.00389 0.00778 0.01167 0.01556 0.01945 0.02335 0.02724 0.03113 0.03502
+ 0.03891 0.0428 0.04669 0.05058 0.05447 0.05836 0.06226 0.06615 0.07004 0.07393
+ 0.07782 0.08171 0.0856 0.08949 0.09338 0.09727 0.10117 0.10506 0.10895 0.11284
+ 0.11673 0.12062 0.12451 0.1284 0.13229 0.13618 0.14008 0.14397 0.14786 0.15175
+ 0.15564 0.15953 0.16342 0.16731 0.1712 0.17509 0.17899 0.18288 0.18677 0.19066
+ 0.19455 0.19844 0.20233 0.20622 0.21011 0.214 0.2179 0.22179 0.22568 0.22957
+ 0.23346 0.23735 0.24124 0.24513 0.24902 0.25291 0.25681 0.2607 0.26459 0.26848
+ 0.27237 0.27626 0.28015 0.28404 0.28793 0.29182 0.29572 0.29961 0.3035 0.30739
+ 0.31128 0.31517 0.31906 0.32295 0.32684 0.33073 0.33463 0.33852 0.34241 0.3463
+ 0.35019 0.35408 0.35797 0.36186 0.36575 0.36964 0.37354 0.37743 0.38132 0.38521
+ 0.3891 0.39299 0.39688 0.40077 0.40466 0.40855 0.41245 0.41634 0.42023 0.42412
+ 0.42801 0.4319 0.43579 0.43968 0.44357 0.44746 0.45135 0.45525 0.45914 0.46303
+ 0.46692 0.47081 0.4747 0.47859 0.48248 0.48637 0.49026 0.49416 0.49805 0.50194
+ 0.50583 0.50972 0.51361 0.5175 0.52139 0.52528 0.52917 0.53307 0.53696 0.54085
+ 0.54474 0.54863 0.55252 0.55641 0.5603 0.56419 0.56808 0.57198 0.57587 0.57976
+ 0.58365 0.58754 0.59143 0.59532 0.59921 0.6031 0.60699 0.61089 0.61478 0.61867
+ 0.62256 0.62645 0.63034 0.63423 0.63812 0.64201 0.6459 0.6498 0.65369 0.65758
+ 0.66147 0.66536 0.66925 0.67314 0.67703 0.68092 0.68481 0.68871 0.6926 0.69649
+ 0.70038 0.70427 0.70816 0.71205 0.71594 0.71983 0.72372 0.72762 0.73151 0.7354
+ 0.73929 0.74318 0.74707 0.75096 0.75485 0.75874 0.76263 0.76653 0.77042 0.77431
+ 0.7782 0.78209 0.78598 0.78987 0.79376 0.79765 0.80154 0.80544 0.80933 0.81322
+ 0.81711 0.821 0.82489 0.82878 0.83267 0.83656 0.84045 0.84435 0.84824 0.85213
+ 0.85602 0.85991 0.8638 0.86769 0.87158 0.87547 0.87936 0.88326 0.88715 0.89104
+ 0.89493 0.89882 0.90271 0.9066 0.91049 0.91438 0.91827 0.92216 0.92606 0.92995
+ 0.93384 0.93773 0.94162 0.94551 0.9494 0.95329 0.95718 0.96107 0.96497 0.96886
+ 0.97275 0.97664 0.98053 0.98442 0.98831 0.9922 0.99609}
+ dup 3 -1 roll 0 1 3 copy 3 -1 roll exch ge
+ {pop pop pop pop pop 256 get}
+ {pop 3 copy pop le {pop pop pop pop 0 get}
+ {exch dup 4 -1 roll exch sub 3 1 roll sub div 256 mul dup
+ floor dup 3 1 roll sub exch cvi dup 1 add 4 -1 roll exch
+ get 4 -1 roll 3 -1 roll get dup 4 1 roll sub mul add}
+ ifelse} ifelse
+ } bind
+ dup
+ ] put
+ dup /MatrixABC [
+ 0.625 0.625 0.625
+ 0.3712 0 0
+ 0 0 -0.928
+ ] put
+ dup /RangeLMN [0 1.1856 0 1 -0.464 1] put
+ dup /DecodeLMN [
+ {-0.1856 add 100 mul 0.625 div
+ dup 8 le {27 24389 div mul}
+ {16 add 116 div dup dup mul mul} ifelse
+ 0.4821087968 mul} bind
+ {100 mul 0.625 div
+ dup 8 le {27 24389 div mul}
+ {16 add 116 div dup dup mul mul} ifelse
+ 0.5000076295 mul} bind
+ {0.464 add 100 mul 0.625 div
+ dup 8 le {27 24389 div mul}
+ {16 add 116 div dup dup mul mul} ifelse
+ 0.4124589914 mul} bind
+ ] put
+ dup /MatrixLMN [1.9999694824 0 0 0 1.9999694824 0 0 0 1.9999694824] put
+ dup /BlackPoint [0.0006352181 0.0006588013 0.0005434487] put
+ dup /WhitePoint [0.9642028809 1 0.8249053955] put]
+ } ifelse
+ /E1 exch /ColorSpace defineRes
+ 
+ cs 0 0 0 0.0407843 sc
+ f
+ n
+ 171.099 673.902 m
+ 171.099 651.303 l
+ 172.503 651.303 l
+ 172.503 673.902 l
+ 171.099 673.902 l
+ 0 0 0 0.988235 sc
+ f
+ n
+ 228.699 673.902 m
+ 228.699 651.303 l
+ 230.202 651.303 l
+ 230.202 673.902 l
+ 228.699 673.902 l
+ f
+ n
+ 180.477 669.141 m
+ 180.477 658.998 l
+ 187.38 658.998 l
+ 187.38 669.141 l
+ 180.477 669.141 l
+ q
+ W
+ n
+ 180.477 658.998 m
+ 187.38 658.998 l
+ 187.38 669.141 l
+ 180.477 669.141 l
+ h
+ 0 0 0 0.0407843 sc
+ f
+ 0 0 0 0.988235 sc
+ q
+ 180.3 659 m
+ /N10 15 Tf
+ (4) show
+ Q
+ Q
+ n
+ 192.366 665.883 m
+ 192.366 658.854 l
+ 196.821 658.854 l
+ 196.821 665.883 l
+ 192.366 665.883 l
+ q
+ W
+ n
+ 192.366 658.854 m
+ 196.821 658.854 l
+ 196.821 665.883 l
+ 192.366 665.883 l
+ h
+ 0 0 0 0.0407843 sc
+ f
+ 0 0 0 0.988235 sc
+ q
+ 191.6 659 m
+ /N10 15 Tf
+ (s) show
+ Q
+ Q
+ n
+ 197.694 667.683 m
+ 197.694 658.854 l
+ 208.719 658.854 l
+ 208.719 667.683 l
+ 197.694 667.683 l
+ q
+ W
+ n
+ 197.694 658.854 m
+ 208.719 658.854 l
+ 208.719 667.683 l
+ 197.694 667.683 l
+ h
+ 0 0 0 0.0407843 sc
+ f
+ 0 0 0 0.988235 sc
+ q
+ 197.5 659 m
+ /N10 15 Tf
+ (to) show
+ Q
+ Q
+ n
+ 209.277 665.901 m
+ 209.277 658.998 l
+ 214.227 658.998 l
+ 214.227 665.901 l
+ 209.277 665.901 l
+ q
+ W
+ n
+ 209.277 658.998 m
+ 214.227 658.998 l
+ 214.227 665.901 l
+ 209.277 665.901 l
+ h
+ 0 0 0 0.0407843 sc
+ f
+ 0 0 0 0.988235 sc
+ q
+ 209.2 659 m
+ /N10 15 Tf
+ (r) show
+ Q
+ Q
+ n
+ 214.677 665.901 m
+ 214.677 658.854 l
+ 220.662 658.854 l
+ 220.662 665.901 l
+ 214.677 665.901 l
+ q
+ W
+ n
+ 214.677 658.854 m
+ 220.662 658.854 l
+ 220.662 665.901 l
+ 214.677 665.901 l
+ h
+ 0 0 0 0.0407843 sc
+ f
+ 0 0 0 0.988235 sc
+ q
+ 214.3 659 m
+ /N10 15 Tf
+ (e) show
+ Q
+ Q
+ Q
+ n
+ 293.3 650.6 m
+ 159.4 650.6 l
+ 159.3 650.6 l
+ 159.1 650.6 l
+ 159 650.7 l
+ 158.9 650.7 l
+ 158.8 650.8 l
+ 158.8 650.9 l
+ 158.7 651 l
+ 158.7 651.1 l
+ 158.6 651.3 l
+ 159.4 651.3 l
+ 159.4 652 l
+ 293.3 652 l
+ 293.3 651.3 l
+ 293.3 650.6 l
+ h
+ eofill
+ n
+ 158.6 651.3 m
+ 158.6 673.9 l
+ 158.6 674 l
+ 158.7 674.1 l
+ 158.7 674.2 l
+ 158.8 674.3 l
+ 158.8 674.4 l
+ 158.9 674.5 l
+ 159 674.6 l
+ 159.1 674.6 l
+ 159.4 674.6 l
+ 159.4 673.9 l
+ 160.1 673.9 l
+ 160.1 651.3 l
+ 159.4 651.3 l
+ 158.6 651.3 l
+ h
+ eofill
+ n
+ 159.4 674.6 m
+ 427.3 674.6 l
+ 427.4 674.6 l
+ 427.5 674.6 l
+ 427.6 674.6 l
+ 427.7 674.5 l
+ 427.8 674.4 l
+ 427.8 674.3 l
+ 427.9 674.2 l
+ 427.9 674.1 l
+ 428 673.9 l
+ 427.3 673.9 l
+ 427.3 673.2 l
+ 159.4 673.2 l
+ 159.4 673.9 l
+ 159.4 674.6 l
+ h
+ eofill
+ n
+ 428 673.9 m
+ 428 651.3 l
+ 428 651.2 l
+ 427.9 651.1 l
+ 427.9 651 l
+ 427.8 650.9 l
+ 427.8 650.8 l
+ 427.7 650.7 l
+ 427.6 650.7 l
+ 427.5 650.6 l
+ 427.3 650.6 l
+ 427.3 651.3 l
+ 426.5 651.3 l
+ 426.5 673.9 l
+ 427.3 673.9 l
+ 428 673.9 l
+ h
+ eofill
+ n
+ 427.3 651.3 m
+ 427.3 650.6 l
+ 293.3 650.6 l
+ 293.3 651.3 l
+ 293.3 652 l
+ 427.3 652 l
+ 427.3 651.3 l
+ h
+ eofill
+ n
+ 157.7 728.4 m
+ 160.8 728.4 l
+ 163.9 728.4 l
+ 167 728.4 l
+ 167 728 l
+ 167 727.6 l
+ 167 727.2 l
+ 163.9 727.2 l
+ 160.8 727.2 l
+ 157.7 727.2 l
+ 157.7 727.6 l
+ 157.7 728 l
+ 157.7 728.4 l
+ h
+ eofill
+ n
+ 167 676.1 m
+ 163.9 676.1 l
+ 160.8 676 l
+ 157.7 676 l
+ 157.7 676.5 l
+ 157.7 676.9 l
+ 157.7 677.3 l
+ 160.8 677.3 l
+ 163.9 677.3 l
+ 167 677.3 l
+ 167 676.9 l
+ 167 676.5 l
+ 167 676.1 l
+ h
+ eofill
+ n
+ 162.7 727.4 m
+ 162.7 677 l
+ 162 677 l
+ 162 727.4 l
+ 162.7 727.4 l
+ h
+ eofill
+ q
+ 109.8 699.5 m
+ /N10 12 Tf
+ (P) show
+ Q
+ q
+ 116.5 699.5 m
+ /N10 12 Tf
+ (r) show
+ Q
+ q
+ 120.5 699.5 m
+ /N10 12 Tf
+ (ologue) show
+ Q
+ n
+ 157 645 m
+ 160 645 l
+ 163.2 645 l
+ 166.3 645 l
+ 166.3 644.6 l
+ 166.3 644.2 l
+ 166.3 643.7 l
+ 163.2 643.7 l
+ 160.1 643.7 l
+ 157 643.7 l
+ 157 644.1 l
+ 157 644.5 l
+ 157 645 l
+ h
+ eofill
+ n
+ 166.3 584.1 m
+ 163.2 584.1 l
+ 160.1 584.1 l
+ 157 584.1 l
+ 156.9 584.5 l
+ 156.9 584.9 l
+ 156.9 585.3 l
+ 160 585.3 l
+ 163.2 585.3 l
+ 166.3 585.3 l
+ 166.3 584.9 l
+ 166.3 584.5 l
+ 166.3 584.1 l
+ h
+ eofill
+ n
+ 162 644 m
+ 162 585.1 l
+ 161.3 585.1 l
+ 161.3 644 l
+ 162 644 l
+ h
+ eofill
+ q
+ 110.4 605.7 m
+ /N10 12 Tf
+ (Epilogue) show
+ Q
+ q
+ 120.6 656.6 m
+ /N10 12 Tf
+ (Ke) show
+ Q
+ q
+ 134.5 656.6 m
+ /N10 12 Tf
+ (r) show
+ Q
+ q
+ 138.5 656.6 m
+ /N10 12 Tf
+ (ne) show
+ Q
+ q
+ 149.8 656.6 m
+ /N10 12 Tf
+ (l) show
+ Q
+ n
+ 263 621.6 m
+ 234.2 621.6 l
+ 234.1 621.6 l
+ 233.9 621.6 l
+ 233.8 621.7 l
+ 233.7 621.7 l
+ 233.6 621.8 l
+ 233.6 621.9 l
+ 233.5 622 l
+ 233.5 622.1 l
+ 233.4 622.3 l
+ 234.2 622.3 l
+ 234.2 623 l
+ 263 623 l
+ 263 622.3 l
+ 263 621.6 l
+ h
+ eofill
+ n
+ 233.4 622.3 m
+ 233.4 708.2 l
+ 233.4 708.3 l
+ 233.5 708.5 l
+ 233.5 708.6 l
+ 233.6 708.7 l
+ 233.6 708.8 l
+ 233.7 708.8 l
+ 233.8 708.9 l
+ 233.9 708.9 l
+ 234.2 709 l
+ 234.2 708.2 l
+ 234.9 708.2 l
+ 234.9 622.3 l
+ 234.2 622.3 l
+ 233.4 622.3 l
+ h
+ eofill
+ n
+ 234.2 709 m
+ 291.8 709 l
+ 291.9 709 l
+ 292 708.9 l
+ 292.1 708.9 l
+ 292.2 708.8 l
+ 292.3 708.8 l
+ 292.4 708.7 l
+ 292.5 708.6 l
+ 292.5 708.5 l
+ 292.5 708.2 l
+ 291.8 708.2 l
+ 291.8 707.5 l
+ 234.2 707.5 l
+ 234.2 708.2 l
+ 234.2 709 l
+ h
+ eofill
+ n
+ 292.5 708.2 m
+ 292.5 622.3 l
+ 292.5 622.2 l
+ 292.5 622.1 l
+ 292.5 622 l
+ 292.4 621.9 l
+ 292.3 621.8 l
+ 292.2 621.7 l
+ 292.1 621.7 l
+ 292 621.6 l
+ 291.8 621.6 l
+ 291.8 622.3 l
+ 291.1 622.3 l
+ 291.1 708.2 l
+ 291.8 708.2 l
+ 292.5 708.2 l
+ h
+ eofill
+ n
+ 291.8 622.3 m
+ 291.8 621.6 l
+ 263 621.6 l
+ 263 622.3 l
+ 263 623 l
+ 291.8 623 l
+ 291.8 622.3 l
+ h
+ eofill
+ q
+ 242.6 693.8 m
+ /N10 15 Tf
+ (1) show
+ Q
+ q
+ 250.2 693.8 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 253.9 693.8 m
+ /N10 15 Tf
+ (lo) show
+ Q
+ q
+ 265.7 693.8 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 272.4 693.8 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 242.6 675.7 m
+ /N10 15 Tf
+ (2) show
+ Q
+ q
+ 250.2 675.7 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 253.9 675.7 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 260.6 675.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 268.2 675.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 242.6 657.4 m
+ /N10 15 Tf
+ (3) show
+ Q
+ q
+ 242.6 639.2 m
+ /N10 15 Tf
+ (4) show
+ Q
+ q
+ 250.2 639.2 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 253.9 639.2 m
+ /N10 15 Tf
+ (s) show
+ Q
+ q
+ 259.8 639.2 m
+ /N10 15 Tf
+ (to) show
+ Q
+ q
+ 271.6 639.2 m
+ /N10 15 Tf
+ (r) show
+ Q
+ q
+ 276.6 639.2 m
+ /N10 15 Tf
+ (e) show
+ Q
+ n
+ 324.6 604.5 m
+ 295.8 604.5 l
+ 295.7 604.5 l
+ 295.6 604.5 l
+ 295.5 604.5 l
+ 295.4 604.6 l
+ 295.3 604.7 l
+ 295.2 604.8 l
+ 295.1 604.9 l
+ 295.1 605 l
+ 295.1 605.2 l
+ 295.8 605.2 l
+ 295.8 605.9 l
+ 324.6 605.9 l
+ 324.6 605.2 l
+ 324.6 604.5 l
+ h
+ eofill
+ n
+ 295.1 605.2 m
+ 295.1 691.1 l
+ 295.1 691.2 l
+ 295.1 691.3 l
+ 295.1 691.5 l
+ 295.2 691.5 l
+ 295.3 691.7 l
+ 295.4 691.7 l
+ 295.5 691.8 l
+ 295.6 691.8 l
+ 295.8 691.9 l
+ 295.8 691.1 l
+ 296.5 691.1 l
+ 296.5 605.2 l
+ 295.8 605.2 l
+ 295.1 605.2 l
+ h
+ eofill
+ n
+ 295.8 691.9 m
+ 353.5 691.9 l
+ 353.7 691.8 l
+ 353.8 691.8 l
+ 353.8 691.7 l
+ 354 691.7 l
+ 354 691.5 l
+ 354.1 691.5 l
+ 354.1 691.3 l
+ 354.2 691.1 l
+ 353.5 691.1 l
+ 353.5 690.4 l
+ 295.8 690.4 l
+ 295.8 691.1 l
+ 295.8 691.9 l
+ h
+ eofill
+ n
+ 354.2 691.1 m
+ 354.2 605.2 l
+ 354.2 605.1 l
+ 354.1 605 l
+ 354.1 604.9 l
+ 354 604.8 l
+ 354 604.7 l
+ 353.8 604.6 l
+ 353.8 604.5 l
+ 353.7 604.5 l
+ 353.5 604.5 l
+ 353.5 605.2 l
+ 352.7 605.2 l
+ 352.7 691.1 l
+ 353.5 691.1 l
+ 354.2 691.1 l
+ h
+ eofill
+ n
+ 353.5 605.2 m
+ 353.5 604.5 l
+ 324.6 604.5 l
+ 324.6 605.2 l
+ 324.6 605.9 l
+ 353.5 605.9 l
+ 353.5 605.2 l
+ h
+ eofill
+ q
+ 304.3 676.7 m
+ /N10 15 Tf
+ (1) show
+ Q
+ q
+ 311.8 676.7 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 315.5 676.7 m
+ /N10 15 Tf
+ (lo) show
+ Q
+ q
+ 327.3 676.7 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 334 676.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 304.3 658.4 m
+ /N10 15 Tf
+ (2) show
+ Q
+ q
+ 311.8 658.4 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 315.5 658.4 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 322.3 658.4 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 329.8 658.4 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 304.3 640.3 m
+ /N10 15 Tf
+ (3) show
+ Q
+ q
+ 304.3 622 m
+ /N10 15 Tf
+ (4) show
+ Q
+ q
+ 315.5 622 m
+ /N10 15 Tf
+ (s) show
+ Q
+ q
+ 321.4 622 m
+ /N10 15 Tf
+ (to) show
+ Q
+ q
+ 333.2 622 m
+ /N10 15 Tf
+ (r) show
+ Q
+ q
+ 338.2 622 m
+ /N10 15 Tf
+ (e) show
+ Q
+ n
+ 386.5 585.6 m
+ 357.7 585.6 l
+ 357.6 585.6 l
+ 357.4 585.6 l
+ 357.3 585.7 l
+ 357.1 585.8 l
+ 357.1 585.9 l
+ 357 586 l
+ 357 586.1 l
+ 356.9 586.3 l
+ 357.7 586.3 l
+ 357.7 587 l
+ 386.5 587 l
+ 386.5 586.3 l
+ 386.5 585.6 l
+ h
+ eofill
+ n
+ 356.9 586.3 m
+ 356.9 672.2 l
+ 356.9 672.3 l
+ 357 672.5 l
+ 357 672.6 l
+ 357.1 672.7 l
+ 357.1 672.8 l
+ 357.3 672.8 l
+ 357.3 672.9 l
+ 357.4 672.9 l
+ 357.7 673 l
+ 357.7 672.2 l
+ 358.4 672.2 l
+ 358.4 586.3 l
+ 357.7 586.3 l
+ 356.9 586.3 l
+ h
+ eofill
+ n
+ 357.7 673 m
+ 415.3 673 l
+ 415.4 673 l
+ 415.5 672.9 l
+ 415.6 672.9 l
+ 415.7 672.8 l
+ 415.8 672.8 l
+ 415.9 672.7 l
+ 416 672.6 l
+ 416 672.5 l
+ 416 672.2 l
+ 415.3 672.2 l
+ 415.3 671.5 l
+ 357.7 671.5 l
+ 357.7 672.2 l
+ 357.7 673 l
+ h
+ eofill
+ n
+ 416 672.2 m
+ 416 586.3 l
+ 416 586.2 l
+ 416 586.1 l
+ 416 586 l
+ 415.9 585.9 l
+ 415.8 585.8 l
+ 415.7 585.7 l
+ 415.6 585.7 l
+ 415.5 585.6 l
+ 415.3 585.6 l
+ 415.3 586.3 l
+ 414.6 586.3 l
+ 414.6 672.2 l
+ 415.3 672.2 l
+ 416 672.2 l
+ h
+ eofill
+ n
+ 415.3 586.3 m
+ 415.3 585.6 l
+ 386.5 585.6 l
+ 386.5 586.3 l
+ 386.5 587 l
+ 415.3 587 l
+ 415.3 586.3 l
+ h
+ eofill
+ q
+ 366.2 657.8 m
+ /N10 15 Tf
+ (1) show
+ Q
+ q
+ 373.8 657.8 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 377.5 657.8 m
+ /N10 15 Tf
+ (lo) show
+ Q
+ q
+ 389.2 657.8 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 395.9 657.8 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 366.2 639.7 m
+ /N10 15 Tf
+ (2) show
+ Q
+ q
+ 373.8 639.7 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 377.5 639.7 m
+ /N10 15 Tf
+ (a) show
+ Q
+ q
+ 384.2 639.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 391.7 639.7 m
+ /N10 15 Tf
+ (d) show
+ Q
+ q
+ 366.2 621.4 m
+ /N10 15 Tf
+ (3) show
+ Q
+ q
+ 366.2 603.2 m
+ /N10 15 Tf
+ (4) show
+ Q
+ q
+ 373.8 603.2 m
+ /N10 15 Tf
+ ( ) show
+ Q
+ q
+ 377.5 603.2 m
+ /N10 15 Tf
+ (s) show
+ Q
+ q
+ 383.3 603.2 m
+ /N10 15 Tf
+ (to) show
+ Q
+ q
+ 395.1 603.2 m
+ /N10 15 Tf
+ (r) show
+ Q
+ q
+ 400.1 603.2 m
+ /N10 15 Tf
+ (e) show
+ Q
+ Q
+ Q
+ PDFVars/TermAll get exec end end
+ userdict /pgsave get restore
+ showpage
+ %%PageTrailer
+ %%EndPage
+ %%Trailer
+ %%DocumentProcessColors: Cyan Magenta Yellow Black
+ %%DocumentSuppliedResources:
+ %%+ font BAAAAA+NimbusRomNo9L-Regu
+ %%+ procset (Adobe Acrobat - PDF operators) 1.2 0
+ %%+ procset (Adobe Acrobat - type operators) 1.2 0
+ %%EOF
+ 
+ %%EndDocument
+ 
+  endTexFig
+  1718 9233 a Fs(\(a\))e(Soft)l(w)l(are)50 b(Pip)t(elined)i(Lo)t(op)5242
+ 7913 y(1)196 b(store)5242 8096 y(2)5242 8278 y(3)g(add)5242
+ 8461 y(4)g(load)6006 8827 y(\(b\))60 b(Kernel)973 9662
+ y Fx(Figure)g(1.3:)80 b(Soft)-5 b(w)g(are)60 b(Pip)5
+ b(elined)58 b(Lo)5 b(op)60 b(with)h(Prologue,)e(Kernel,)h(and)g
+ (Epilogue)3855 11136 y(3)p eop end
+ %%Page: 4 11
+ TeXDict begin 4 10 bop 0 183 a Ft(1.2)270 b(Researc)-7
+ b(h)88 b(Con)-7 b(tributions)91 b(of)f(this)f(Thesis)0
+ 728 y Fx(The)59 b(\014rst)f(main)g(con)-5 b(tribution)57
+ b(of)h(this)f(thesis)g(is)h(an)h(implemen)-5 b(tation)55
+ b(of)j(Swing)g(Mo)5 b(dulo)58 b(Sc)-5 b(heduling)57 b(in)h(the)0
+ 1093 y(LL)-20 b(VM)78 b(Compiler)g(Infrastructure)g([26)o(].)136
+ b(The)79 b(results)f(sho)-5 b(w)79 b(that)g(it)f(is)h(an)g(e\013ectiv)
+ -5 b(e)77 b(and)i(e\016cien)-5 b(t)78 b(Mo)5 b(d-)0 1459
+ y(ulo)66 b(Sc)-5 b(heduling)66 b(tec)-5 b(hnique.)98
+ b(Our)68 b(implemen)-5 b(tation)63 b(sho)-5 b(ws)67 b(that)f(Swing)h
+ (Mo)5 b(dulo)66 b(Sc)-5 b(heduling)66 b(successfully)0
+ 1824 y(ac)-5 b(hiev)g(es)59 b(an)i(optimal)d(sc)-5 b(hedule)59
+ b(while)h(reducing)g(register)g(pressure)g(\(for)g(most)f(cases\).)282
+ 2190 y(The)47 b(second)f(main)g(con)-5 b(tribution)44
+ b(of)j(this)e(thesis)g(is)h(to)g(extend)g(the)h(Swing)f(Mo)5
+ b(dulo)46 b(Sc)-5 b(heduling)45 b(algorithm)0 2555 y(to)50
+ b(handle)g(more)g(than)g(single)f(basic)g(blo)5 b(c)-5
+ b(k)50 b(lo)5 b(ops.)76 b(W)-15 b(e)50 b(ha)-5 b(v)g(e)50
+ b(mo)5 b(di\014ed)49 b(the)h(algorithm)f(to)h(handle)g(sup)5
+ b(erblo)g(c)-5 b(k)0 2920 y(lo)5 b(ops)50 b(\(single-en)-5
+ b(try)-15 b(,)50 b(m)-5 b(ultiple-exit,)49 b(m)-5 b(ultiple)49
+ b(basic)h(blo)5 b(c)-5 b(k)51 b(lo)5 b(ops\).)76 b(These)51
+ b(extensions)e(allo)-5 b(w)51 b(the)g(algorithm)0 3286
+ y(to)60 b(b)5 b(e)61 b(applied)e(at)h(v)-10 b(arious)60
+ b(stages)f(of)h(compilation:)273 3801 y Fr(\017)91 b
+ Fx(Statically:)d(Just)66 b(as)f(the)h(original)e(Swing)i(Mo)5
+ b(dulo)65 b(Sc)-5 b(heduling)64 b(algorithm)g(w)-5 b(as)66
+ b(done)g(statically)-15 b(,)63 b(the)455 4166 y(extensions)58
+ b(simply)h(expand)h(the)h(n)-5 b(um)g(b)5 b(er)60 b(of)g(lo)5
+ b(ops)59 b(acceptable)g(for)i(this)e(transformation.)273
+ 4681 y Fr(\017)91 b Fx(O\017ine:)83 b(Using)62 b(pro\014le)f
+ (information,)g(hot)h(paths)f(\(subsets)g(of)h(the)g(lo)5
+ b(op)62 b(in)g(the)g(form)f(of)h(single)f(en)-5 b(try)-15
+ b(,)455 5046 y(m)-5 b(ultiple)58 b(exit)h(lo)5 b(ops\),)59
+ b(can)i(b)5 b(e)60 b(recognized)f(and)i(b)5 b(e)60 b(transformed)g(b)-5
+ b(y)60 b(our)h(extensions.)273 5561 y Fr(\017)91 b Fx(Run)-5
+ b(time:)119 b(Similar)79 b(to)h(the)g(pro\014le)h(driv)-5
+ b(en)80 b(optimization,)i(hot)f(paths)f(are)h(found)f(during)g(program)
+ 455 5926 y(execution,)58 b(and)j(are)f(transformed)f(dynamically)g
+ (using)g(the)i(extended)e(algorithm.)0 6684 y Ft(1.3)270
+ b(Organization)89 b(of)i(this)e(Thesis)0 7229 y Fx(This)48
+ b(thesis)f(b)5 b(egins)48 b(with)g(bac)-5 b(kground)49
+ b(information)d(in)i(Chapter)h(2)g(on)f(sc)-5 b(heduling.)75
+ b(In)48 b(order)h(to)g(understand)0 7595 y(wh)-5 b(y)60
+ b(Swing)f(Mo)5 b(dulo)58 b(Sc)-5 b(heduling)58 b(w)-5
+ b(as)59 b(c)-5 b(hosen,)58 b(an)h(o)-5 b(v)g(erview)59
+ b(of)g(Mo)5 b(dulo)58 b(Sc)-5 b(heduling)58 b(and)h(Global)f(Mo)5
+ b(dulo)0 7960 y(Sc)-5 b(heduling)58 b(approac)-5 b(hes,)59
+ b(along)g(with)h(related)f(w)-5 b(ork)60 b(is)f(presen)-5
+ b(ted)59 b(in)g(Chapter)h(3.)80 b(The)60 b(implemen)-5
+ b(tation)57 b(of)0 8325 y(Swing)67 b(Mo)5 b(dulo)66 b(Sc)-5
+ b(heduling)66 b(is)h(explained)e(in)i(Chapter)h(4)f(and)g(extensions)e
+ (to)i(the)g(algorithm)f(are)h(detailed)0 8691 y(in)72
+ b(Chapter)g(5.)116 b(The)72 b(implemen)-5 b(tation)69
+ b(and)k(extensions)d(of)i(this)f(algorithm)g(are)h(ev)-10
+ b(aluated)71 b(in)h(Chapter)h(6.)0 9056 y(Finally)-15
+ b(,)58 b(Chapter)j(7)f(discuss)f(p)5 b(oten)-5 b(tial)59
+ b(future)h(w)-5 b(ork,)60 b(and)h(concludes)e(this)h(w)-5
+ b(ork.)3855 11136 y(4)p eop end
+ %%Page: 5 12
+ TeXDict begin 5 11 bop 0 1428 a Fv(Chapter)129 b(2)0
+ 2258 y Fw(Sc)-13 b(heduling)156 b(Bac)-13 b(kground)0
+ 3288 y Fu(Instruction)55 b(Sc)-5 b(heduling)55 b Fx(aims)g(to)i
+ (rearrange)f(instructions)f(to)h(\014ll)g(the)g(gap)h(that)f(the)g
+ (dela)-5 b(y)56 b(b)5 b(et)-5 b(w)g(een)56 b(dep)5 b(en-)0
+ 3653 y(den)-5 b(t)57 b(instructions)f(creates.)78 b(If)58
+ b(other)f(instructions)f(w)-5 b(ere)58 b(not)f(sc)-5
+ b(heduled)57 b(in)g(this)g(gap,)h(the)f(pro)5 b(cessor)57
+ b(w)-5 b(ould)0 4019 y(stall)46 b(and)j(w)-5 b(aste)47
+ b(cycles.)75 b(Instruction)46 b(sc)-5 b(heduling)47 b(is)g(t)-5
+ b(ypically)46 b(done)i(after)f(mac)-5 b(hine)47 b(indep)5
+ b(enden)-5 b(t)47 b(optimiza-)0 4384 y(tions,)70 b(and)f(either)f(b)5
+ b(efore)69 b(or)g(after)f(register)h(allo)5 b(cation.)103
+ b(Dep)5 b(ending)69 b(up)5 b(on)69 b(the)g(compiler)e(infrastructure,)0
+ 4749 y(sc)-5 b(heduling)52 b(is)h(done)h(on)g(target)f(mac)-5
+ b(hine)52 b(assem)-5 b(bly)-15 b(,)53 b(or)h(on)g(a)f(lo)-5
+ b(w-lev)g(el)52 b(represen)-5 b(tation)52 b(that)h(closely)f(mo)5
+ b(dels)0 5115 y(assem)-5 b(bly)-15 b(.)282 5480 y(All)58
+ b(Instruction)g(Sc)-5 b(heduling)57 b(tec)-5 b(hniques)57
+ b(aim)h(to)g(pro)5 b(duce)59 b(an)g Fu(optimal)e(sc)-5
+ b(hedule)p Fx(,)57 b(a)i(sc)-5 b(hedule)57 b(with)h(the)0
+ 5845 y(shortest)d(length.)77 b(Sc)-5 b(hedule)55 b(length)f(is)h
+ (measured)g(as)h(the)f(total)f(execution)g(time)h(in)g(cycles.)77
+ b(In)56 b(addition,)e(the)0 6211 y(optimal)59 b(sc)-5
+ b(hedule)59 b(m)-5 b(ust)59 b(b)5 b(e)61 b(found)f(in)g(a)h(reasonable)
+ e(amoun)-5 b(t)60 b(of)g(time.)282 6576 y(Instruction)53
+ b(Sc)-5 b(heduling)54 b(algorithms)e(m)-5 b(ust)54 b(satisfy)f(b)5
+ b(oth)54 b(dep)5 b(endence)54 b(and)h(resource)f(constrain)-5
+ b(ts)53 b(when)0 6942 y(creating)74 b(a)h(sc)-5 b(hedule.)123
+ b(Dep)5 b(endence)74 b(constrain)-5 b(ts)74 b(are)h(determined)e(b)-5
+ b(y)75 b(constructing)f(a)h(data)g(dep)5 b(endence)0
+ 7307 y(graph,)91 b(a)84 b(directed)g(graph)h(whose)g(no)5
+ b(des)84 b(represen)-5 b(t)84 b(instructions,)89 b(and)c(edges)f
+ (represen)-5 b(t)84 b(a)h(dep)5 b(endence)0 7672 y(b)g(et)-5
+ b(w)g(een)82 b(instructions.)143 b(A)82 b(dep)5 b(endence)81
+ b(b)5 b(et)-5 b(w)g(een)82 b(t)-5 b(w)g(o)82 b(instructions)e(is)i
+ (formed)f(when)h(t)-5 b(w)g(o)82 b(instructions)0 8038
+ y(ha)-5 b(v)g(e)60 b(a)h(common)e(op)5 b(erand,)60 b(and)h(one)f(of)g
+ (those)g(instructions)e(de\014nes)i(the)g(op)5 b(erand.)282
+ 8403 y(If)43 b(resource)f(constrain)-5 b(ts)41 b(are)j(met,)h(the)d(sc)
+ -5 b(hedule)42 b(will)g(not)h(require)f(more)h(resources)f(then)h(the)g
+ (arc)-5 b(hitecture)0 8768 y(has)83 b(a)-5 b(v)-10 b(ailable.)147
+ b(Instruction)81 b(Sc)-5 b(heduling)82 b(m)-5 b(ust)83
+ b(ha)-5 b(v)g(e)83 b(a)g(resource)g(usage)g(mo)5 b(del)82
+ b(that)h(breaks)g(do)-5 b(wn)83 b(the)0 9134 y(resource)56
+ b(p)5 b(er)56 b(pip)5 b(eline)55 b(stage)g(for)h(eac)-5
+ b(h)56 b(category)g(of)g(instructions)e(\(i.e.,)h(loads,)g(in)-5
+ b(teger)56 b(arithmetic,)e(\015oating)0 9499 y(p)5 b(oin)-5
+ b(t)49 b(arithmetic,)h(etc\).)76 b(Using)49 b(this)h(resource)f(mo)5
+ b(del,)51 b(the)e(sc)-5 b(heduler)50 b(can)f(p)5 b(opulate)50
+ b(a)g Fu(resource)f(reserv)-10 b(ation)0 9865 y(table)p
+ Fx(.)79 b(A)59 b(resource)g(reserv)-10 b(ation)58 b(table)g(is)g(a)h
+ (matrix)f(in)h(the)g(form)f(of)g Fq(r)43 b Fr(\002)38
+ b Fq(c)59 b Fx(where,)g Fq(r)64 b Fx(is)58 b(the)h(resources,)f(and)h
+ Fq(c)0 10230 y Fx(is)c(the)g(cycles)g(of)g(the)g(sc)-5
+ b(hedule.)78 b(Eac)-5 b(h)55 b(en)-5 b(try)55 b(in)h(this)f(table)f(is)
+ h(an)h(instruction)e(that)h(uses)g(a)h(resource)f(for)h(that)0
+ 10595 y(cycle.)3855 11136 y(5)p eop end
+ %%Page: 6 13
+ TeXDict begin 6 12 bop 282 183 a Fx(While)54 b(\014nding)h(the)g
+ (optimal)e(sc)-5 b(hedule)54 b(is)g(the)h(main)f(goal,)h(Instruction)f
+ (Sc)-5 b(heduling)53 b(m)-5 b(ust)55 b(also)f(b)5 b(e)55
+ b(a)-5 b(w)g(are)0 548 y(of)85 b(the)h(p)5 b(oten)-5
+ b(tial)83 b(increase)i(of)g Fu(register)g(pressure)g
+ Fx(b)-5 b(y)86 b(reordering)f(instructions.)154 b(Register)84
+ b(pressure)h(is)g(a)0 913 y(measure)51 b(of)g(the)g(n)-5
+ b(um)g(b)5 b(er)52 b(of)f(liv)-5 b(e)50 b(v)-10 b(alues)51
+ b(at)g(a)h(giv)-5 b(en)51 b(p)5 b(oin)-5 b(t)51 b(in)g(the)g(program.)
+ 77 b(A)53 b Fu(Liv)-5 b(e)50 b(Range)h Fx(is)g(a)h(range)g(from)0
+ 1279 y(when)63 b(a)g(v)-10 b(alue)62 b(is)g(de\014ned,)h(to)f(its)g
+ (\014nal)h(use)f(in)h(the)f(program.)87 b(A)63 b(v)-10
+ b(alue)62 b(is)g(liv)-5 b(e)62 b(at)h(a)g(giv)-5 b(en)62
+ b(p)5 b(oin)-5 b(t)62 b(if)g(the)g(last)0 1644 y(use)54
+ b(of)h(that)f(v)-10 b(alue)54 b(has)h(not)f(o)5 b(ccurred.)78
+ b(Because)54 b(arc)-5 b(hitectures)53 b(ha)-5 b(v)g(e)55
+ b(limited)d(registers,)i(the)h(n)-5 b(um)g(b)5 b(er)54
+ b(of)g(liv)-5 b(e)0 2010 y(v)-10 b(alues)64 b(should)g(not)g(exceed)g
+ (the)g(total)g(n)-5 b(um)g(b)5 b(er)64 b(of)g(registers)g(a)-5
+ b(v)-10 b(ailable.)91 b(If)64 b(that)g(v)-10 b(alue)64
+ b(has)g(b)5 b(een)64 b(exceeded,)0 2375 y(the)50 b(registers)f(are)h
+ Fu(spilled)e Fx(to)i(memory)f(and)i(loaded)e(again)h(when)g(needed.)76
+ b(Reading)50 b(and)g(writing)f(to)h(memory)0 2740 y(can)60
+ b(b)5 b(e)61 b(quite)e(costly)-15 b(.)282 3106 y(Instruction)40
+ b(Sc)-5 b(heduling)39 b(can)i(b)5 b(e)41 b(brok)-5 b(en)40
+ b(in)-5 b(to)40 b(three)h(categories:)69 b Fu(Lo)5 b(cal)40
+ b(Sc)-5 b(heduling)p Fx(,)42 b Fu(Global)e(Sc)-5 b(heduling)p
+ Fx(,)0 3471 y(and)87 b Fu(Cyclic)g(Sc)-5 b(heduling)86
+ b Fx([36)o(].)160 b(Lo)5 b(cal)87 b(Sc)-5 b(heduling)86
+ b(handles)g(single)g(basic)g(blo)5 b(c)-5 b(ks)87 b(whic)-5
+ b(h)87 b(are)g(regions)g(of)0 3836 y(straigh)-5 b(t)66
+ b(line)f(co)5 b(de)67 b(that)f(ha)-5 b(v)g(e)67 b(a)g(single)e(en)-5
+ b(try)67 b(and)f(exit.)99 b(Global)65 b(Sc)-5 b(heduling)66
+ b(can)g(handle)h(m)-5 b(ultiple)64 b(basic)0 4202 y(blo)5
+ b(c)-5 b(ks)54 b(with)h(acyclic)e(con)-5 b(trol)55 b(\015o)-5
+ b(w,)55 b(and)h(Cyclic)e(Sc)-5 b(heduling)53 b(handles)i(single)e(or)j
+ (m)-5 b(ultiple)52 b(basic)i(blo)5 b(c)-5 b(ks)54 b(with)0
+ 4567 y(cyclic)59 b(con)-5 b(trol)60 b(\015o)-5 b(w.)80
+ b(Soft)-5 b(w)g(are)60 b(Pip)5 b(elining)58 b(falls)h(in)-5
+ b(to)60 b(the)g(latter)f(category)-15 b(.)282 4933 y(Lo)5
+ b(cal)45 b(Sc)-5 b(heduling)45 b(t)-5 b(ypically)43 b(uses)j(a)g(form)f
+ (of)g Fu(List)g(Sc)-5 b(heduling)p Fx(.)74 b(List)44
+ b(Sc)-5 b(heduling)45 b(sc)-5 b(hedules)44 b(instructions)0
+ 5298 y(starting)59 b(at)i(cycle)e(zero,)h(un)-5 b(til)60
+ b(all)f(instructions)g(ha)-5 b(v)g(e)60 b(b)5 b(een)60
+ b(sc)-5 b(heduled.)80 b(F)-15 b(or)60 b(eac)-5 b(h)60
+ b(cycle)g(it)g(main)-5 b(tains)58 b(a)j(list)0 5663 y(of)53
+ b(ready)h(instructions)e(\(those)h(with)g(no)h(resource)f(or)h(dep)5
+ b(endence)53 b(con\015icts\),)g(and)h(sc)-5 b(hedules)52
+ b(that)h(list)g(in)g(an)0 6029 y(order)61 b(based)f(up)5
+ b(on)60 b(some)g(heuristic.)79 b(Here)60 b(are)h(a)f(few)h(of)f(the)g
+ (traditional)e(heuristics)h(used:)273 6553 y Fr(\017)91
+ b Fx(Maxim)-5 b(um)49 b(distance)g(\(latency\))h(from)g(the)h(no)5
+ b(de,)52 b(to)f(a)g(no)5 b(de)51 b(without)g(successors.)75
+ b(This)51 b(is)g(also)f(kno)-5 b(wn)455 6918 y(as)60
+ b Fu(heigh)-5 b(t-based)58 b Fx(priorit)-5 b(y)-15 b(.)273
+ 7420 y Fr(\017)91 b Fx(Maxim)-5 b(um)58 b(n)-5 b(um)g(b)5
+ b(er)60 b(of)g(c)-5 b(hildren,)59 b(direct)h(or)h(all)e(descendan)-5
+ b(ts.)273 7921 y Fr(\017)91 b Fx(Smallest)50 b Fp(est)-12
+ b(ar)g(t)54 b Fx(v)-10 b(alue,)52 b(where)h Fp(est)-12
+ b(ar)g(t)54 b Fx(is)d(equal)h(to)g(the)g(total)f(latency)g(of)h(the)g
+ (no)5 b(de's)52 b(predecessors.)273 8422 y Fr(\017)91
+ b Fx(Smallest)58 b Fp(lst)-12 b(ar)g(t)62 b Fx(v)-10
+ b(alue,)59 b(where)i Fp(lst)-12 b(ar)g(t)62 b Fx(is)d(equal)h(to)g(the)
+ h(total)e(latency)g(of)h(the)g(no)5 b(de's)60 b(successors.)273
+ 8924 y Fr(\017)91 b Fx(Lo)-5 b(w)g(er)60 b Fu(Mobilit)-5
+ b(y)p Fx(,)58 b(where)j(Mobilit)-5 b(y)58 b(is)i(the)g(di\013erence)f
+ (b)5 b(et)-5 b(w)g(een)60 b Fp(lst)-12 b(ar)g(t)62 b
+ Fx(and)f Fp(est)-12 b(ar)g(t)p Fx(.)273 9425 y Fr(\017)91
+ b Fx(No)5 b(des)60 b(on)h(the)f(critical)e(path,)i(whic)-5
+ b(h)60 b(means)g(they)g(ha)-5 b(v)g(e)60 b(a)h(mobilit)-5
+ b(y)58 b(of)i(zero.)282 9949 y(Lo)5 b(cal)64 b(Sc)-5
+ b(heduling)64 b(is)g(limited)f(b)5 b(ecause)64 b(it)h(op)5
+ b(erates)64 b(only)g(on)i(single)d(basic)h(blo)5 b(c)-5
+ b(ks)64 b(whic)-5 b(h)65 b(are)g(t)-5 b(ypically)0 10315
+ y(not)87 b(v)-5 b(ery)88 b(large.)161 b(Therefore,)94
+ b(while)87 b(optimal)f(sc)-5 b(hedules)86 b(ma)-5 b(y)87
+ b(b)5 b(e)88 b(found)f(for)g(those)g(small)f(regions,)93
+ b(the)0 10680 y(o)-5 b(v)g(erall)52 b(impact)h(on)g(p)5
+ b(erformance)53 b(could)g(b)5 b(e)54 b(quite)e(small.)77
+ b(Global)52 b(Sc)-5 b(heduling)52 b(sc)-5 b(hedules)52
+ b(instructions)g(from)3855 11136 y(6)p eop end
+ %%Page: 7 14
+ TeXDict begin 7 13 bop 0 183 a Fx(m)-5 b(ultiple)59 b(basic)h(blo)5
+ b(c)-5 b(ks)60 b(and)h(o)-5 b(v)g(erlaps)60 b(the)g(execution)g(of)h
+ (instructions)e(from)h(di\013eren)-5 b(t)60 b(basic)g(blo)5
+ b(c)-5 b(ks.)81 b(There)0 548 y(exist)59 b(man)-5 b(y)60
+ b(Global)f(Sc)-5 b(heduling)60 b(algorithms)e([36)o(])i(suc)-5
+ b(h)61 b(as:)273 1113 y Fr(\017)91 b Fx(T)-15 b(race)57
+ b(Sc)-5 b(heduling:)77 b(It)57 b(iden)-5 b(ti\014es)55
+ b(frequen)-5 b(tly)56 b(executed)h(traces)f(in)h(the)g(program)g(and)h
+ (treats)e(the)h(path)455 1478 y(as)j(an)g(extended)g(basic)g(blo)5
+ b(c)-5 b(k)59 b(whic)-5 b(h)61 b(is)e(sc)-5 b(heduled)60
+ b(using)f(a)i(list)e(sc)-5 b(heduling)59 b(approac)-5
+ b(h.)273 1993 y Fr(\017)91 b Fx(Sup)5 b(erblo)g(c)-5
+ b(k)81 b(Sc)-5 b(heduling:)121 b(Sup)5 b(erblo)g(c)-5
+ b(ks)81 b(are)h(a)f(subset)g(of)h(traces)f(whic)-5 b(h)81
+ b(ha)-5 b(v)g(e)81 b(a)h(single)f(en)-5 b(try)81 b(and)455
+ 2358 y(m)-5 b(ultiple)84 b(exit)j(attributes)e(\(therefore)h(they)h
+ (are)g(traces)g(without)f(side)h(exits\).)158 b(List)86
+ b(sc)-5 b(heduling)86 b(is)455 2724 y(t)-5 b(ypically)58
+ b(used)i(to)g(sc)-5 b(hedule)60 b(the)g(sup)5 b(erblo)g(c)-5
+ b(k.)273 3238 y Fr(\017)91 b Fx(Hyp)5 b(erblo)g(c)-5
+ b(k)70 b(Sc)-5 b(heduling:)99 b(Excessiv)-5 b(e)69 b(con)-5
+ b(trol)70 b(\015o)-5 b(w)70 b(can)h(complicate)d(sc)-5
+ b(heduling,)71 b(so)g(this)e(approac)-5 b(h)455 3604
+ y(uses)79 b(a)h(tec)-5 b(hnique)79 b(called)g(If-Con)-5
+ b(v)g(ersion)79 b([3)o(])h(to)g(remo)-5 b(v)g(e)79 b(conditional)f
+ (branc)-5 b(hes.)139 b(If-Con)-5 b(v)g(ersion)79 b(is)455
+ 3969 y(discussed)58 b(in)j(Section)e(3.2.2.)282 4534
+ y(With)54 b(this)g(bac)-5 b(kground)54 b(in)g(Instruction)f(Sc)-5
+ b(heduling,)54 b(Soft)-5 b(w)g(are)54 b(Pip)5 b(elining,)52
+ b(a)j(form)f(of)g(Cyclic)f(Sc)-5 b(hedul-)0 4899 y(ing,)60
+ b(will)f(b)5 b(e)60 b(discussed)f(in)h(great)h(detail)e(in)h(Chapter)g
+ (3.)3855 11136 y(7)p eop end
+ %%Page: 8 15
+ TeXDict begin 8 14 bop 0 1428 a Fv(Chapter)129 b(3)0
+ 2258 y Fw(Previous)157 b(W)-39 b(ork)0 3288 y Fx(Soft)-5
+ b(w)g(are)69 b(Pip)5 b(elining)68 b([9)o(])h(is)h(a)f(group)h(of)g(tec)
+ -5 b(hniques)68 b(that)h(aim)g(to)g(exploit)g(Instruction)f(Lev)-5
+ b(el)68 b(P)-5 b(arallelism)0 3653 y(\(ILP\))85 b(b)-5
+ b(y)86 b(o)-5 b(v)g(erlapping)85 b(successiv)-5 b(e)84
+ b(iterations)g(of)i(a)g(lo)5 b(op.)157 b(Ov)-5 b(er)87
+ b(the)f(y)-5 b(ears,)91 b(t)-5 b(w)g(o)87 b(main)e(approac)-5
+ b(hes)85 b(to)0 4019 y(Soft)-5 b(w)g(are)80 b(Pip)5 b(elining)77
+ b(ha)-5 b(v)g(e)80 b(dev)-5 b(elop)5 b(ed:)119 b Fu(Mo)-5
+ b(v)g(e-then-Sc)g(hedule)p Fx(,)81 b(and)g Fu(Sc)-5 b(hedule-then-Mo)g
+ (v)g(e)p Fx(.)136 b(The)80 b(Mo)-5 b(v)g(e-)0 4384 y(then-Sc)g(hedule)
+ 39 b(tec)-5 b(hniques)40 b([16)o(,)h(30,)g(14,)g(22],)j(whic)-5
+ b(h)41 b(will)f(not)h(b)5 b(e)41 b(discussed)f(in)h(this)f(thesis,)k
+ (mo)-5 b(v)g(e)40 b(instructions)0 4749 y(across)77 b(the)h(bac)-5
+ b(k-edge)77 b(of)h(the)g(lo)5 b(op)77 b(in)h(order)g(to)g(ac)-5
+ b(hiev)g(e)77 b(a)h(pip)5 b(elined)76 b(lo)5 b(op.)133
+ b(The)78 b(Sc)-5 b(hedule-then-Mo)g(v)g(e)0 5115 y(algorithms)41
+ b(attempt)h(to)h(create)g(a)g(sc)-5 b(hedule)43 b(that)f(maximizes)f(p)
+ 5 b(erformance)42 b(and)i(constructs)e(a)h(new)h(pip)5
+ b(elined)0 5480 y(lo)g(op)60 b(comp)5 b(osed)59 b(of)h(instructions)f
+ (from)h(curren)-5 b(t)60 b(and)g(previous)g(iterations.)282
+ 5845 y(The)85 b(Sc)-5 b(hedule-then-Mo)g(v)g(e)81 b(group)k(of)f(tec)-5
+ b(hniques)82 b(is)i(further)g(decomp)5 b(osed)83 b(in)-5
+ b(to)84 b(t)-5 b(w)g(o)84 b(families.)149 b(The)0 6211
+ y(\014rst)82 b(is)f(kno)-5 b(wn)82 b(as)g Fu(Unroll-based)f(Sc)-5
+ b(heduling)p Fx(,)86 b(whic)-5 b(h)81 b(use)h(lo)5 b(op)82
+ b(unrolling)e(while)i(sc)-5 b(heduling)80 b(to)i(form)f(a)0
+ 6576 y(soft)-5 b(w)g(are)87 b(pip)5 b(elined)87 b(lo)5
+ b(op.)162 b(It)88 b(rep)5 b(eats)88 b(this)f(pro)5 b(cess)87
+ b(un)-5 b(til)87 b(the)h(sc)-5 b(hedule)87 b(b)5 b(ecomes)87
+ b(a)h(rep)5 b(etition)86 b(of)i(an)0 6942 y(existing)55
+ b(sc)-5 b(hedule.)77 b(As)57 b(one)g(can)f(sp)5 b(eculate,)55
+ b(this)h(t)-5 b(yp)5 b(e)56 b(of)g(approac)-5 b(h)57
+ b(often)f(leads)f(to)i(high)f(time)f(complexit)-5 b(y)-15
+ b(.)0 7307 y(The)59 b(second)f(group,)h Fu(Mo)5 b(dulo)57
+ b(Sc)-5 b(heduling)58 b Fx([27)o(,)g(33,)g(12,)h(21)o(,)g(4,)f(16,)g
+ (28],)g(aims)f(to)i(create)f(a)g(sc)-5 b(hedule)58 b(with)g(no)0
+ 7672 y(resource)j(or)h(dep)5 b(endence)61 b(con\015icts)f(that)h(can)g
+ (b)5 b(e)62 b(rep)5 b(eated)61 b(at)g(a)g(constan)-5
+ b(t)61 b(in)-5 b(terv)-10 b(al.)82 b(Since)61 b(Swing)g(Mo)5
+ b(dulo)0 8038 y(Sc)-5 b(heduling)60 b(\(SMS\))h(falls)e(in)-5
+ b(to)61 b(the)g(second)g(category)-15 b(,)60 b(this)g(thesis)g(will)g
+ (brie\015y)h(describ)5 b(e)61 b(a)g(few)g(of)g(the)g(other)0
+ 8403 y(w)-5 b(ell)60 b(kno)-5 b(wn)60 b(algorithms)f(in)h(this)g
+ (category)-15 b(.)282 8768 y(Mo)5 b(dulo)69 b(Sc)-5 b(heduling)68
+ b(is)h(traditionally)d(restricted)i(to)i(single)d(basic)i(blo)5
+ b(c)-5 b(k)69 b(lo)5 b(ops)68 b(without)h(con)-5 b(trol)68
+ b(\015o)-5 b(w,)0 9134 y(whic)g(h)44 b(can)g(limit)e(the)h(n)-5
+ b(um)g(b)5 b(er)44 b(of)g(candidate)f(lo)5 b(ops.)74
+ b(Global)42 b(Soft)-5 b(w)g(are)44 b(Pip)5 b(elining)42
+ b(tec)-5 b(hniques)42 b(ha)-5 b(v)g(e)44 b(emerged)0
+ 9499 y(to)61 b(exploit)f(some)h(of)g(the)g(opp)5 b(ortunities)60
+ b(for)h(ILP)g(in)g(m)-5 b(ultiple)59 b(basic)h(blo)5
+ b(c)-5 b(k)61 b(lo)5 b(ops)61 b(that)g(frequen)-5 b(tly)60
+ b(o)5 b(ccur)61 b(in)0 9865 y(computation)73 b(in)-5
+ b(tensiv)g(e)72 b(applications.)120 b(W)-15 b(e)74 b(will)g(explore)f
+ (a)i(few)f(tec)-5 b(hniques)73 b(in)h(this)g(area,)j(as)e(it)e
+ (directly)0 10230 y(relates)59 b(to)h(the)h(SMS)f(extensions)f
+ (discussed)g(in)h(Chapter)g(5.)3855 11136 y(8)p eop end
+ %%Page: 9 16
+ TeXDict begin 9 15 bop 0 183 a Ft(3.1)270 b(Mo)7 b(dulo)92
+ b(Sc)-7 b(heduling)90 b(Approac)-7 b(hes)0 728 y Fx(Mo)5
+ b(dulo)42 b(Sc)-5 b(heduling)42 b(tec)-5 b(hniques)42
+ b(t)-5 b(ypically)41 b(use)i(heuristic)e(based)i(approac)-5
+ b(hes)43 b(to)g(\014nd)g(a)g(near-optimal)e(sc)-5 b(hed-)0
+ 1093 y(ule.)75 b(While)47 b(there)g(exist)f(other)h(approac)-5
+ b(hes,)49 b(suc)-5 b(h)47 b(as)h(en)-5 b(umerating)46
+ b(all)g(p)5 b(ossible)46 b(solutions)g(and)h(c)-5 b(ho)5
+ b(osing)46 b(the)0 1459 y(b)5 b(est)58 b(one)h([4)o(],)f(\014nding)g
+ (the)h(optimal)e(sc)-5 b(hedule)57 b(is)h(an)h(NP-complete)d(problem.)
+ 79 b(Therefore,)58 b(most)g(pro)5 b(duction)0 1824 y(compilers)59
+ b([18)o(])h(implemen)-5 b(t)58 b(Mo)5 b(dulo)60 b(Sc)-5
+ b(heduling)59 b(using)h(heuristic)e(based)i(algorithms.)282
+ 2190 y(Mo)5 b(dulo)72 b(Sc)-5 b(heduling)71 b(algorithms)f(exhibit)h
+ (the)h(same)g(pattern)g(when)g(pip)5 b(elining)71 b(a)h(lo)5
+ b(op)72 b(\(Figure)f(3.1\).)0 2555 y(Eac)-5 b(h)75 b(b)5
+ b(egins)75 b(b)-5 b(y)76 b(constructing)e(a)i Fu(Data)f(Dep)5
+ b(endence)75 b(Graph)h Fx(\(DDG\).)e(Using)i(the)f(DDG,)g(the)g
+ Fu(Minim)-5 b(um)0 2920 y(Initiation)74 b(In)-5 b(terv)-10
+ b(al)74 b Fx(\(MI)5 b(I\),)75 b(whic)-5 b(h)75 b(is)h(the)f(minim)-5
+ b(um)74 b(amoun)-5 b(t)75 b(of)h(time)f(b)5 b(et)-5 b(w)g(een)75
+ b(the)h(start)g(of)f(successiv)-5 b(e)0 3286 y(iterations)75
+ b(of)i(a)g(lo)5 b(op,)80 b(is)c(computed.)129 b(Mo)5
+ b(dulo)76 b(Sc)-5 b(heduling)76 b(algorithms)f(aim)h(to)h(create)g(a)g
+ (sc)-5 b(hedule)75 b(with)0 3651 y(an)c Fu(Initiation)e(In)-5
+ b(terv)-10 b(al)70 b Fx(\(I)5 b(I\))69 b(equal)i(to)g(MI)5
+ b(I,)69 b(whic)-5 b(h)71 b(is)g(the)f(smallest)f(I)5
+ b(I)70 b(p)5 b(ossible)70 b(and)h(results)f(in)g(the)h(most)0
+ 4016 y(optimal)59 b(sc)-5 b(hedule.)79 b(The)60 b(lo)-5
+ b(w)g(er)61 b(the)f(I)5 b(I,)59 b(the)h(greater)h(the)f(parallelism.)
+ 282 4382 y(MI)5 b(I)81 b(is)h(de\014ned)g(to)f(b)5 b(e)82
+ b(the)g(maxim)-5 b(um)80 b(of)h(the)h(resource)g(constrained)e(I)5
+ b(I)82 b(\(ResMI)5 b(I\),)79 b(and)j(recurrence)0 4747
+ y(constrained)74 b(I)5 b(I)76 b(\(RecMI)5 b(I\))73 b(of)j(the)f(lo)5
+ b(op.)126 b(The)76 b(exact)f(ResMI)5 b(I)74 b(ma)-5 b(y)75
+ b(b)5 b(e)76 b(calculated)e(b)-5 b(y)75 b(using)g(reserv)-10
+ b(ation)0 5113 y(tables,)85 b(a)d(metho)5 b(d)80 b(of)h(mo)5
+ b(deling)80 b(resource)h(usage,)86 b(but)c(this)e(can)h(lead)g(to)h
+ (exp)5 b(onen)-5 b(tial)79 b(complexit)-5 b(y)80 b([33)o(].)0
+ 5478 y(Mo)5 b(dulo)57 b(Sc)-5 b(heduling)56 b(algorithms)f(t)-5
+ b(ypically)55 b(use)i(an)h(appro)-5 b(ximation)55 b(b)-5
+ b(y)58 b(computing)e(the)h(total)f(usage)h(coun)-5 b(t)0
+ 5843 y(for)60 b(eac)-5 b(h)60 b(resource)g(and)h(using)f(the)g(most)f
+ (hea)-5 b(vily)60 b(used)g(resource)g(coun)-5 b(t)60
+ b(as)g(ResMI)5 b(I.)282 6209 y(Recurrences)57 b(in)h(the)f(data)h(dep)5
+ b(endence)57 b(graph)h(o)5 b(ccur)58 b(when)g(there)f(is)h(a)f(dep)5
+ b(endence)58 b(from)f(one)g(instruc-)0 6574 y(tion)50
+ b(to)h(another)g(from)f(a)h(previous)f(iteration.)76
+ b(These)50 b(lo)5 b(op-carried)50 b(dep)5 b(endences)50
+ b(ha)-5 b(v)g(e)51 b(a)g(distance)e(prop)5 b(ert)-5 b(y)0
+ 6939 y(whic)g(h)81 b(is)f(equal)g(to)h(the)f(n)-5 b(um)g(b)5
+ b(er)81 b(of)g(iterations)e(separating)g(the)i(t)-5 b(w)g(o)81
+ b(instructions)e(in)-5 b(v)g(olv)g(ed.)140 b(Using)80
+ b(the)0 7305 y(data)72 b(dep)5 b(endence)72 b(graph,)j(all)c
+ (recurrences)h(are)h(found)f(using)g(an)-5 b(y)72 b(circuit)f
+ (\014nding)h(algorithm)6869 7239 y Fo(1)6946 7305 y Fx(.)116
+ b(F)-15 b(or)73 b(eac)-5 b(h)0 7670 y(recurrence,)71
+ b(I)5 b(I)70 b(is)f(calculated)e(using)i(the)h(total)e(latencies)g
+ (\(L\))h(of)g(all)g(the)g(instructions,)h(the)f(total)g(distance)0
+ 8036 y(\(D\),)58 b(and)i(the)e(follo)-5 b(wing)58 b(constrain)-5
+ b(t:)78 b Fq(L)38 b Fr(\000)g Fq(I)14 b(I)53 b Fr(\003)37
+ b Fq(D)56 b(<)p Fx(=)51 b(0.)80 b(The)59 b(recurrence)g(with)g(the)g
+ (highest)f(calculated)g(I)5 b(I)0 8401 y(sets)60 b(the)g(RecMI)5
+ b(I.)1545 8819 y Fs(1)196 b Fn(8)p Fm(b)51 b Fn(2)h Fs(Single)f(basic)g
+ (blo)t(c)l(k)g(lo)t(ops)g(without)g(con)l(trol)f(\015o)l(w)1545
+ 9002 y(2)358 b Fm(D)t(D)t(G)43 b Fs(=)52 b(Data)e(dep)t(endence)55
+ b(graph)c(for)g Fm(b)1545 9185 y Fs(3)358 b Fm(M)16 b(I)c(I)55
+ b Fs(=)d(max\()p Fm(R)q(ecM)16 b(I)c(I)g Fs(,)51 b Fm(R)q(esM)16
+ b(I)c(I)g Fs(\))1545 9367 y(4)358 b Fm(S)8 b(chedul)r(e)p
+ Fs(\()p Fm(b)p Fs(\))497 b(//Algorithms)50 b(di\013er)h(on)g(this)g
+ (step)1545 9550 y(5)358 b Fm(R)q(econstr)t(uct)p Fs(\()p
+ Fm(b)p Fs(\))281 b(//Reconstruct)51 b(in)l(to)g(prologue,)g(k)l(ernel,)
+ g(epilogue)1643 9887 y Fx(Figure)60 b(3.1:)79 b(Pseudo)60
+ b(Co)5 b(de)61 b(for)f(General)g(Mo)5 b(dulo)59 b(Sc)-5
+ b(heduling)p 0 9932 3120 7 v 207 10040 a Fl(1)276 10103
+ y Fs(Circuit)59 b(\014nding)g(algorithms)e(\014nd)i(all)f(circuits)g
+ (\(a)g(path)h(where)g(the)g(\014rst)f(and)h(last)f(no)t(de)h(are)g
+ (iden)l(tical\))f(where)h(no)g(v)l(ertex)0 10286 y(app)t(ears)52
+ b(t)l(wice.)3855 11136 y Fx(9)p eop end
+ %%Page: 10 17
+ TeXDict begin 10 16 bop 282 183 a Fx(Using)49 b(the)g(MI)5
+ b(I)49 b(v)-10 b(alue)48 b(as)h(their)g(initial)e(I)5
+ b(I)49 b(v)-10 b(alue,)50 b(the)f(algorithms)e(attempt)h(to)h(sc)-5
+ b(hedule)48 b(eac)-5 b(h)49 b(instruction)0 548 y(in)62
+ b(the)g(lo)5 b(op)62 b(using)f(some)h(set)g(of)f(heuristics.)84
+ b(The)63 b(set)f(of)f(heuristics)g(used)h(v)-10 b(aries)61
+ b(widely)h(across)g(implemen-)0 913 y(tations)76 b(of)h(Mo)5
+ b(dulo)76 b(Sc)-5 b(heduling.)130 b(If)77 b(an)g(optimal)f(sc)-5
+ b(hedule)76 b(can)h(not)g(b)5 b(e)77 b(obtained,)k(I)5
+ b(I)76 b(is)h(increased,)j(and)0 1279 y(the)68 b(algorithm)e(attempts)g
+ (to)i(compute)f(the)g(sc)-5 b(hedule)67 b(again.)102
+ b(This)68 b(pro)5 b(cess)67 b(is)g(rep)5 b(eated)68 b(un)-5
+ b(til)66 b(a)i(sc)-5 b(hedule)0 1644 y(is)73 b(obtained)g(or)h(the)f
+ (algorithm)f(giv)-5 b(es)73 b(up)h(\(t)-5 b(ypically)71
+ b(b)5 b(ecause)73 b(I)5 b(I)74 b(has)f(reac)-5 b(hed)74
+ b(a)f(v)-10 b(alue)73 b(greater)h(than)f(the)0 2010 y(original)59
+ b(lo)5 b(op's)59 b(length)h(in)g(cycles\).)282 2375 y(F)-15
+ b(rom)68 b(this)f(sc)-5 b(hedule,)68 b(the)g(lo)5 b(op)67
+ b(is)h(then)g(reconstructed)e(in)-5 b(to)68 b(a)g(prologue,)h(a)f(k)-5
+ b(ernel,)69 b(and)f(an)g(epilogue.)0 2740 y(The)57 b(prologue)g(b)5
+ b(egins)56 b(the)h(\014rst)f Fu(n)i Fx(iterations.)77
+ b(After)56 b Fu(n)i Fr(\003)f Fu(I)5 b(I)56 b Fx(cycles,)g(a)h(steady)f
+ (state)g(is)h(ac)-5 b(hiev)g(ed)56 b(and)h(a)g(new)0
+ 3106 y(iteration)69 b(is)g(initiated)f(ev)-5 b(ery)70
+ b(I)5 b(I)69 b(cycles.)108 b(The)71 b(epilogue)d(\014nishes)h(the)h
+ (last)f Fu(n)h Fx(iterations.)107 b(Lo)5 b(ops)70 b(with)g(long)0
+ 3471 y(execution)59 b(times)g(will)g(sp)5 b(end)61 b(the)f(ma)10
+ b(jorit)-5 b(y)59 b(of)h(their)g(time)f(in)h(the)g(k)-5
+ b(ernel.)282 3836 y(A)65 b(side)f(e\013ect)g(of)g(Mo)5
+ b(dulo)64 b(Sc)-5 b(heduling)63 b(is)h(that)g(register)g(pressure)g(is)
+ g(inheren)-5 b(tly)63 b(increased)h(when)h(o)-5 b(v)g(er-)0
+ 4202 y(lapping)60 b(successiv)-5 b(e)59 b(iterations.)81
+ b(If)60 b(register)g(pressure)h(increases)f(b)5 b(ey)-5
+ b(ond)61 b(the)g(a)-5 b(v)-10 b(ailable)59 b(registers,)g(registers)0
+ 4567 y(m)-5 b(ust)53 b(b)5 b(e)54 b(spilled)e(and)i(the)f(e\013ectiv)-5
+ b(e)53 b(I)5 b(I)53 b(is)h(unin)-5 b(ten)g(tionally)51
+ b(increased.)76 b(If)54 b(this)f(situation)f(arises,)h(the)h(Mo)5
+ b(dulo)0 4933 y(Sc)-5 b(heduled)60 b(lo)5 b(op)60 b(is)f(t)-5
+ b(ypically)59 b(discarded,)g(and)h(the)h(original)e(lo)5
+ b(op)60 b(is)f(used)i(instead.)282 5298 y(This)56 b(thesis)f(will)h
+ (brie\015y)g(discuss)f(three)h(Mo)5 b(dulo)55 b(Sc)-5
+ b(heduling)55 b(algorithms)g(whic)-5 b(h)56 b(use)g(the)g(pattern)g
+ (men-)0 5663 y(tioned)k(ab)5 b(o)-5 b(v)g(e,)59 b(and)i(that)f(are)g
+ (similar)f(to)h(SMS.)0 6294 y Fk(3.1.1)225 b(Iterativ)-6
+ b(e)76 b(Mo)6 b(dulo)74 b(Sc)-6 b(heduling)0 6777 y Fu(Iterativ)h(e)43
+ b(Mo)5 b(dulo)44 b(Sc)-5 b(heduling)44 b Fx([33)o(])h(\(IMS\))f(uses)g
+ (simple)f(extensions)g(to)i(the)f(common)g(acyclic)f(list)h(sc)-5
+ b(heduling)0 7142 y(algorithm)80 b(and)h(the)g(heigh)-5
+ b(t-based)80 b(priorit)-5 b(y)80 b(function.)142 b(IMS)81
+ b(b)5 b(egins)81 b(b)-5 b(y)81 b(constructing)f(a)h(standard)g(data)0
+ 7507 y(dep)5 b(endence)61 b(graph,)g(but)h(also)e(includes)h(t)-5
+ b(w)g(o)61 b(pseudo-op)5 b(erations:)80 b Fp(st)-12 b(ar)g(t)63
+ b Fx(and)f Fp(stop)p Fx(.)84 b(The)62 b Fp(st)-12 b(ar)g(t)62
+ b Fx(no)5 b(de)62 b(is)0 7873 y(made)j(to)g(b)5 b(e)65
+ b(the)h(predecessor)e(of)h(all)g(no)5 b(des)65 b(in)g(graph)g(and)h
+ (the)f Fp(stop)h Fx(no)5 b(de)66 b(is)e(the)i(successor)e(to)h(all)f
+ (no)5 b(des)0 8238 y(in)60 b(the)g(graph.)282 8604 y(IMS)45
+ b(then)h(pro)5 b(ceeds)45 b(to)g(calculate)f(MI)5 b(I,)44
+ b(whic)-5 b(h)45 b(is)g(the)g(maxim)-5 b(um)44 b(of)h(ResMI)5
+ b(I)44 b(and)i(RecMI)5 b(I)44 b(\(Section)g(3.1\).)0
+ 8969 y(Using)72 b(MI)5 b(I)72 b(as)g(the)g(initial)f(I)5
+ b(I)71 b(v)-10 b(alue,)75 b(IMS)d(sc)-5 b(hedules)71
+ b(all)g(the)h(instructions)f(using)h(a)g(mo)5 b(di\014ed)72
+ b(acyclic)f(list)0 9334 y(sc)-5 b(heduling)55 b(algorithm.)77
+ b(IMS's)56 b(list)f(sc)-5 b(heduling)55 b(algorithm)g(di\013ers)h(from)
+ g(traditional)f(list)g(sc)-5 b(heduling)55 b(in)h(the)0
+ 9700 y(follo)-5 b(wing)59 b(w)-5 b(a)g(ys:)273 10214
+ y Fr(\017)91 b Fx(IMS)80 b(\014nds)h(the)f(optimal)g(time)f(slot)h(for)
+ h(eac)-5 b(h)80 b(instruction)g(instead)f(of)i(sc)-5
+ b(heduling)79 b(all)h(instructions)455 10580 y(p)5 b(ossible)58
+ b(p)5 b(er)61 b(time)e(slot.)79 b(Additionally)-15 b(,)58
+ b(instructions)h(can)h(b)5 b(e)60 b(unsc)-5 b(heduled)60
+ b(and)g(then)g(resc)-5 b(heduled.)3809 11136 y(10)p eop
+ end
+ %%Page: 11 18
+ TeXDict begin 11 17 bop 273 183 a Fr(\017)91 b Fx(When)41
+ b(determining)e(whic)-5 b(h)41 b(instruction)e(to)i(sc)-5
+ b(hedule)41 b(next,)j(the)d(instruction)e(with)i(the)g(highest)f
+ (priorit)-5 b(y)455 548 y(is)50 b(returned)h(based)f(up)5
+ b(on)51 b(a)g(giv)-5 b(en)50 b(priorit)-5 b(y)50 b(sc)-5
+ b(heme.)76 b(Instructions)49 b(ma)-5 b(y)50 b(b)5 b(e)51
+ b(returned)g(more)f(then)g(once)455 913 y(since)59 b(they)h(ma)-5
+ b(y)60 b(b)5 b(e)61 b(unsc)-5 b(heduled)59 b(and,)h(later,)f(resc)-5
+ b(heduled.)273 1428 y Fr(\017)91 b Fp(est)-12 b(ar)g(t)51
+ b Fx(is)e(a)h(prop)5 b(ert)-5 b(y)49 b(that)h(represen)-5
+ b(ts)49 b(the)g(earliest)f(time)g(an)i(instruction)e(ma)-5
+ b(y)50 b(b)5 b(e)49 b(sc)-5 b(heduled)49 b(\(based)455
+ 1794 y(up)5 b(on)61 b(the)h(predecessors)e(in)i(the)f(partial)f(sc)-5
+ b(hedule\).)83 b(Because)60 b(an)i(instruction's)d(predecessors)i(can)g
+ (b)5 b(e)455 2159 y(unsc)-5 b(heduled)64 b(and)i(a)g(no)5
+ b(de)65 b(can)h(b)5 b(e)66 b(resc)-5 b(heduled,)65 b
+ Fp(est)-12 b(ar)g(t)67 b Fx(main)-5 b(tains)64 b(a)i(history)f(of)g
+ (past)g(v)-10 b(alues)65 b(and)455 2524 y(uses)60 b(either)g(the)h
+ (curren)-5 b(t)61 b Fp(est)-12 b(ar)g(t)63 b Fx(\(if)d(it)h(is)f(less)g
+ (than)h(the)g(last)f Fp(est)-12 b(ar)g(t)63 b Fx(v)-10
+ b(alue\),)60 b(or)h(one)g(cycle)f(greater)455 2890 y(than)j(the)h(last)
+ f Fp(est)-12 b(ar)g(t)p Fx(.)93 b(This)64 b(is)f(to)h(prev)-5
+ b(en)g(t)64 b(instructions)e(from)h(rep)5 b(eatedly)64
+ b(causing)f(eac)-5 b(h)63 b(other)h(to)455 3255 y(b)5
+ b(e)60 b(unsc)-5 b(heduled)59 b(and)i(resc)-5 b(heduled)59
+ b(with)h(no)h(c)-5 b(hange)60 b(in)g(the)g(sc)-5 b(hedule.)273
+ 3770 y Fr(\017)91 b Fx(A)80 b(sp)5 b(ecial)78 b(v)-5
+ b(ersion)79 b(of)g(the)h(sc)-5 b(hedule)79 b(reserv)-10
+ b(ation)78 b(table,)83 b(a)d Fu(mo)5 b(dulo)79 b(reserv)-10
+ b(ation)79 b(table)p Fx(,)k(is)c(used)g(in)455 4135 y(order)72
+ b(to)f(adhere)h(to)f(the)g(mo)5 b(dulo)71 b(constrain)-5
+ b(t.)113 b(Eac)-5 b(h)71 b(instruction)f(uses)h(time-slot)e(mo)5
+ b(dulo)71 b(I)5 b(I)71 b(when)455 4501 y(b)5 b(eing)59
+ b(inserted)h(in)-5 b(to)60 b(the)g(sc)-5 b(hedule.)273
+ 5015 y Fr(\017)91 b Fx(The)53 b(maxim)-5 b(um)51 b(time)h(slot)g(an)i
+ (instruction)d(ma)-5 b(y)53 b(b)5 b(e)53 b(sc)-5 b(heduled)52
+ b(is)g(limited)f(to)i(the)g Fq(minT)25 b(ime)h Fx(+)g
+ Fq(I)14 b(I)39 b Fr(\000)26 b Fx(1,)455 5381 y(whic)-5
+ b(h)60 b(di\013ers)g(from)f(traditional)g(list)g(sc)-5
+ b(heduling)59 b(that)h(uses)g Fr(1)g Fx(as)g(its)g(maxim)-5
+ b(um)58 b(time.)273 5896 y Fr(\017)91 b Fx(If)59 b(a)i(sc)-5
+ b(hedule)59 b(could)h(not)g(b)5 b(e)61 b(found,)e(the)h(algorithm)f
+ (giv)-5 b(es)60 b(up.)282 6410 y(IMS)66 b(extends)g(the)g(heigh)-5
+ b(t)65 b(based)h(priorit)-5 b(y)66 b(function)f(to)h(tak)-5
+ b(e)66 b(lo)5 b(op)66 b(carried)g(dep)5 b(endencies)65
+ b(in)-5 b(to)65 b(consid-)0 6776 y(eration.)78 b(An)59
+ b(instruction's)c(heigh)-5 b(t)57 b(is)g(equal)g(to)g(the)h(heigh)-5
+ b(t)56 b(of)i(the)f(no)5 b(de)58 b(in)f(the)g(graph,)h(min)-5
+ b(us)57 b(the)g(pro)5 b(duct)0 7141 y(of)60 b(I)5 b(I)60
+ b(and)h(the)f(distance)f(from)h(the)g(instruction)e(to)j(its)e
+ (predecessor.)282 7507 y(Once)k(a)f(sc)-5 b(heduling)61
+ b(order)i(has)f(b)5 b(een)63 b(determined,)e(the)h(range)g(of)g(time)f
+ (slots)g(eac)-5 b(h)63 b(instruction)d(ma)-5 b(y)62 b(b)5
+ b(e)0 7872 y(issued)71 b(to)h(is)g(determined)f(b)-5
+ b(y)72 b(predecessors)f(already)h(inserted)f(in)-5 b(to)71
+ b(the)h(sc)-5 b(hedule.)115 b Fp(est)-12 b(ar)g(t)73
+ b Fx(is)f(calculated)0 8237 y(considering)52 b(those)i(immediate)d
+ (predecessors,)i(whic)-5 b(h)54 b(preserv)-5 b(es)53
+ b(the)h(dep)5 b(endence)53 b(b)5 b(et)-5 b(w)g(een)53
+ b(the)h(instruction)0 8603 y(and)67 b(its)f(predecessors.)98
+ b(The)67 b(dep)5 b(endence)67 b(b)5 b(et)-5 b(w)g(een)66
+ b(the)h(instruction)e(b)5 b(eing)66 b(sc)-5 b(heduled)66
+ b(and)h(its)f(successors)0 8968 y(is)55 b(preserv)-5
+ b(ed)55 b(b)-5 b(y)56 b(asserting)f(that)g(if)g(an)-5
+ b(y)55 b(resource)h(or)g(dep)5 b(endence)55 b(con\015ict)f(should)h(o)5
+ b(ccur,)56 b(the)g(instruction's)0 9333 y(successors)74
+ b(are)i(unsc)-5 b(heduled.)125 b(There)76 b(is)g(no)g(strategy)e(for)i
+ (determining)e(whic)-5 b(h)76 b(successor)e(to)i(remo)-5
+ b(v)g(e,)78 b(as)0 9699 y(IMS)60 b(remo)-5 b(v)g(es)59
+ b(them)h(all.)79 b(The)61 b(displaced)e(instructions)f(will)i(then)g(b)
+ 5 b(e)60 b(resc)-5 b(heduled)60 b(at)g(a)g(later)g(time.)282
+ 10064 y(An)80 b(extensiv)-5 b(e)78 b(study)h(w)-5 b(as)79
+ b(done)g(on)h(the)f(e\013ectiv)-5 b(eness)77 b(of)i(IMS)g([10)o(])g
+ (and)h(other)f(Mo)5 b(dulo)78 b(Sc)-5 b(heduling)0 10430
+ y(approac)g(hes.)96 b(It)65 b(determined)f(that)i(IMS)f(has)h(a)g(high)
+ f(register)g(requiremen)-5 b(t)64 b(\(unlik)-5 b(e)65
+ b(SMS\),)g(but)h(computes)3809 11136 y(11)p eop end
+ %%Page: 12 19
+ TeXDict begin 12 18 bop 0 183 a Fx(a)61 b(sc)-5 b(hedule)59
+ b(with)h(near)g(optimal)f(I)5 b(I)60 b(for)g(complex)f(arc)-5
+ b(hitectures)4566 117 y Fo(2)4644 183 y Fx(.)0 808 y
+ Fk(3.1.2)225 b(Slac)-6 b(k)74 b(Mo)6 b(dulo)74 b(Sc)-6
+ b(heduling)0 1290 y Fu(Slac)h(k)59 b(Mo)5 b(dulo)58 b(Sc)-5
+ b(heduling)58 b Fx([21])h(\(Slac)-5 b(k\))58 b(is)g(a)i(bidirectional)d
+ (Mo)5 b(dulo)58 b(Sc)-5 b(heduling)58 b(strategy)h(that)g(sc)-5
+ b(hedules)0 1656 y(some)58 b(instructions)f(late,)h(and)h(some)f(early)
+ -15 b(.)79 b(As)60 b(with)f(all)f(Mo)5 b(dulo)58 b(Sc)-5
+ b(heduling)58 b(algorithms,)f(Slac)-5 b(k)58 b(attempts)0
+ 2021 y(to)51 b(create)h(su\016cien)-5 b(t)50 b(iteration)g(o)-5
+ b(v)g(erlap)51 b(suc)-5 b(h)51 b(that)g(the)h(lo)5 b(op)51
+ b(initiates)e(iterations)h(at)i(the)f(maxim)-5 b(um)50
+ b(p)5 b(ossible)0 2387 y(issue)88 b(rate.)167 b(The)90
+ b(Slac)-5 b(k)88 b(sc)-5 b(heduling)88 b(algorithm)g(tak)-5
+ b(es)88 b(resource)h(and)h(recurrence)f(constrain)-5
+ b(ts,)94 b(register)0 2752 y(pressure,)56 b(and)f(critical)f(paths)h
+ (in)-5 b(to)55 b(consideration)e(when)j(p)5 b(erforming)55
+ b(instruction)e(sc)-5 b(heduling)54 b(and)i(to)f(limit)0
+ 3117 y(bac)-5 b(k-trac)g(king.)73 b(The)43 b(term)f(\\slac)-5
+ b(k")41 b(refers)i(to)f(the)h(amoun)-5 b(t)42 b(of)g(freedom)g(the)g
+ (instruction)f(has)i(in)f(its)g(placemen)-5 b(t)0 3483
+ y(in)60 b(the)g(sc)-5 b(hedule.)282 3848 y(The)80 b(algorithm)f(b)5
+ b(egins)79 b(b)-5 b(y)80 b(constructing)e(a)i(data)g(dep)5
+ b(endence)79 b(graph)h(\(DDG\).)f(Using)g(the)h(DDG,)f(it)0
+ 4213 y(computes)70 b(the)h(MI)5 b(I)70 b(v)-10 b(alue)71
+ b(b)-5 b(y)71 b(examining)f(the)h(resource)g(and)g(recurrence)g
+ (constrain)-5 b(ts.)112 b(It)70 b(uses)h(the)g(same)0
+ 4579 y(algorithm)61 b(as)h(IMS)g(to)g(determine)f(ResMI)5
+ b(I)61 b(and)h(RecMI)5 b(I,)61 b(and)h(uses)g(the)g(maxim)-5
+ b(um)60 b(as)j(the)f(v)-10 b(alue)61 b(for)h(MI)5 b(I.)0
+ 4944 y(Lik)-5 b(e)67 b(IMS,)h(it)g(uses)g(t)-5 b(w)g(o)68
+ b(pseudo)g(instructions:)94 b Fp(st)-12 b(ar)g(t)70 b
+ Fx(and)e Fp(stop)p Fx(.)105 b Fp(st)-12 b(ar)g(t)70 b
+ Fx(is)e(a)g(predecessor)g(to)g(all)f(no)5 b(des)0 5310
+ y(in)64 b(the)f(DDG)h(and)g(is)f(sc)-5 b(heduled)63 b(at)h(a)g(\014xed)
+ g(issue)f(slot,)g(cycle)g(0.)91 b Fp(stop)65 b Fx(is)e(a)h(successor)f
+ (to)h(all)f(no)5 b(des)64 b(in)f(the)0 5675 y(DDG)53
+ b(and)g(is)g(sc)-5 b(heduled)52 b(lik)-5 b(e)52 b(an)-5
+ b(y)54 b(other)f(instruction.)76 b(The)54 b(purp)5 b(ose)53
+ b(of)g(the)g Fp(st)-12 b(ar)g(t)54 b Fx(and)g Fp(stop)g
+ Fx(no)5 b(des)53 b(are)g(to)0 6040 y(ensure)60 b(that)f(the)h
+ Fp(est)-12 b(ar)g(t)61 b Fx(and)f Fp(lst)-12 b(ar)g(t)61
+ b Fx(are)f(w)-5 b(ell)59 b(de\014ned)h(for)g(all)f(instructions)f
+ (\(there)h(is)g(nev)-5 b(er)60 b(a)g(situation)0 6406
+ y(where)h(a)f(no)5 b(de)61 b(do)5 b(es)60 b(not)g(ha)-5
+ b(v)g(e)60 b(a)h(predecessor)e(or)i(successor)e(in)h(the)h(sc)-5
+ b(hedule\).)282 6771 y(During)40 b(all)g(stages)f(of)h(the)g
+ (algorithm,)i(the)e(sc)-5 b(heduler)39 b(main)-5 b(tains)38
+ b(a)i(minim)-5 b(um)38 b(distance)h(relation)g(\()p Fp(mindist)p
+ Fx(\))0 7136 y(b)5 b(et)-5 b(w)g(een)70 b(all)f(pairs)h(of)g
+ (instructions.)108 b(Main)-5 b(taining)68 b(the)i Fp(mindist)g
+ Fx(relation)f(e\013ectiv)-5 b(ely)68 b(k)-5 b(eeps)70
+ b(trac)-5 b(k)70 b(of)f(the)0 7502 y(earliest)60 b(start)h(time)f(\()p
+ Fp(est)-12 b(ar)g(t)p Fx(\))63 b(and)e(the)h(latest)e(start)h(time)f
+ (\()p Fp(lst)-12 b(ar)g(t)p Fx(\))62 b(b)5 b(ounds)62
+ b(for)f(eac)-5 b(h)61 b(instruction,)f(giv)-5 b(en)0
+ 7867 y(the)66 b(partial)g(sc)-5 b(hedule.)98 b Fp(mindist)66
+ b Fx(is)g(the)h(minim)-5 b(um)64 b(n)-5 b(um)g(b)5 b(er)66
+ b(of)h(cycles)e(that)i(a)f(giv)-5 b(en)66 b(instruction)f(m)-5
+ b(ust)66 b(b)5 b(e)0 8233 y(issued)49 b(b)5 b(efore)49
+ b(its)g(successor.)76 b(If)49 b(there)h(is)f(no)h(path)g(b)5
+ b(et)-5 b(w)g(een)49 b(t)-5 b(w)g(o)50 b(instructions,)g
+ Fp(mindist)f Fx(is)h(set)f(to)h Fr(\0001)p Fx(.)77 b(The)0
+ 8598 y Fp(mindist)62 b Fx(computation)e(is)h(reduced)h(to)f(an)h
+ (all-pairs)e(shortest)h(path)h(algorithm)e(b)-5 b(y)62
+ b(negating)f(the)h(distances)0 8963 y(on)f(eac)-5 b(h)60
+ b(dep)5 b(endence.)79 b(It)60 b(is)g(imp)5 b(ortan)-5
+ b(t)59 b(to)h(note)g(that)g Fp(mindist)g Fx(m)-5 b(ust)60
+ b(b)5 b(e)60 b(recalculated)f(for)h(eac)-5 b(h)60 b(new)h(I)5
+ b(I.)282 9329 y(The)61 b(Slac)-5 b(k)60 b(sc)-5 b(heduling)59
+ b(algorithm)f(is)i(outlined)f(as)i(follo)-5 b(ws:)222
+ 9814 y(1.)91 b Fj(Selecting)59 b(an)g(Instruction)i(to)e(b)6
+ b(e)59 b(Sc)-6 b(heduled)p Fx(:)76 b(Slac)-5 b(k)51 b(c)-5
+ b(ho)5 b(oses)50 b(instructions)f(with)i(the)g(minim)-5
+ b(um)455 10180 y(n)g(um)g(b)5 b(er)64 b(of)g(issue)f(slots,)h
+ (con\015ict)f(free)h(placemen)-5 b(ts,)63 b(to)h(b)5
+ b(e)65 b(sc)-5 b(heduled)63 b(\014rst.)92 b(This)64 b(prop)5
+ b(ert)-5 b(y)65 b(is)e(called)p 0 10326 3120 7 v 207
+ 10434 a Fl(2)276 10497 y Fs(Complex)j(arc)l(hitectures)g(are)g(those)f
+ (whic)l(h)h(pip)t(eline)g(simple)g(instructions,)h(while)f(complex)g
+ (ones)g(\(fp)f(division,)j(mo)t(dulo,)0 10680 y(square)51
+ b(ro)t(ot\))g(are)g(not)g([10].)3809 11136 y Fx(12)p
+ eop end
+ %%Page: 13 20
+ TeXDict begin 13 19 bop 455 183 a Fx(the)76 b(dynamic)f(priorit)-5
+ b(y)76 b(of)g(an)g(instruction.)127 b(The)76 b(n)-5 b(um)g(b)5
+ b(er)76 b(of)h(issue)e(slots)g(is)h(appro)-5 b(ximated)75
+ b(b)-5 b(y)76 b(the)455 548 y(slac)-5 b(k)68 b(v)-10
+ b(alue)69 b(when)g(there)g(is)g(no)g(resource)g(con)-5
+ b(ten)g(tion.)106 b(If)69 b(con)-5 b(ten)g(tion)67 b(o)5
+ b(ccurs,)71 b(the)e(n)-5 b(um)g(b)5 b(er)69 b(of)g(issue)455
+ 913 y(slots)52 b(is)g(appro)-5 b(ximated)52 b(b)-5 b(y)54
+ b(dividing)d(the)i(slac)-5 b(k)53 b(v)-10 b(alue)52 b(in)h(half.)77
+ b(If)53 b(there)g(is)g(a)g(tie)f(for)h(dynamic)g(priorit)-5
+ b(y)-15 b(,)455 1279 y(the)67 b(instruction)f(with)h(the)g(lo)-5
+ b(w)g(est)67 b Fp(lst)-12 b(ar)g(t)69 b Fx(is)e(c)-5
+ b(hosen.)100 b(The)68 b(slac)-5 b(k)67 b(v)-10 b(alue)67
+ b(is)g(the)g(di\013erence)g(b)5 b(et)-5 b(w)g(een)455
+ 1644 y Fp(lst)-12 b(ar)g(t)61 b Fx(and)g Fp(est)-12 b(ar)g(t)p
+ Fx(.)222 2139 y(2.)91 b Fj(Cho)6 b(osing)83 b(the)i(Issue)h(Cycle)p
+ Fx(:)106 b(A)74 b(sophisticated)d(heuristic)g(that)i(analyzes)f(\015o)
+ -5 b(w)74 b(dep)5 b(endencies)72 b(is)455 2504 y(used)47
+ b(to)h(determine)f(if)h(the)g(instruction)e(should)i(b)5
+ b(e)48 b(placed)f(as)h(early)g(as)g(p)5 b(ossible)46
+ b(or)j(as)f(late)f(as)h(p)5 b(ossible.)222 2999 y(3.)91
+ b Fj(Sc)-6 b(heduling)87 b(an)g(Instruction)p Fx(:)111
+ b(If)75 b(no)h(con\015ict)e(free)h(issue)f(slot)h(exists)f(for)h(the)g
+ (instruction)f(b)5 b(eing)455 3365 y(sc)-5 b(heduled,)52
+ b(then)g(one)g(or)h(more)f(instructions)e(m)-5 b(ust)51
+ b(b)5 b(e)53 b(ejected)e(from)g(the)h(sc)-5 b(hedule.)77
+ b(The)52 b(instructions)455 3730 y(to)j(b)5 b(e)56 b(ejected)e(are)h
+ (those)g(issued)g(after)g Fp(lst)-12 b(ar)g(t)57 b Fx(for)e(the)h
+ (instruction)d(b)5 b(eing)55 b(sc)-5 b(heduled.)78 b(If)55
+ b(an)g(instruc-)455 4095 y(tion)68 b(is)h(b)5 b(eing)68
+ b(resc)-5 b(heduled,)70 b(the)f(maxim)-5 b(um)67 b(of)i
+ Fp(est)-12 b(ar)g(t)71 b Fx(and)e(one)h(plus)e(the)h(last)f(placemen)-5
+ b(t)68 b(slot,)i(is)455 4461 y(used)c(as)g(the)g Fp(est)-12
+ b(ar)g(t)68 b Fx(v)-10 b(alue.)97 b(This)66 b(prev)-5
+ b(en)g(ts)66 b(instructions)e(from)i(con)-5 b(tin)g(uously)65
+ b(ejecting)f(eac)-5 b(h)66 b(other)455 4826 y(from)e(the)h(sc)-5
+ b(hedule.)92 b Fp(est)-12 b(ar)g(t)67 b Fx(and)e Fp(lst)-12
+ b(ar)g(t)66 b Fx(for)f(all)f(instructions)f(are)i(up)5
+ b(dated)65 b(after)f(an)h(instruction)455 5191 y(is)59
+ b(successfully)f(sc)-5 b(heduled)59 b(or)i(unsc)-5 b(heduled.)222
+ 5686 y(4.)91 b Fj(Incremen)-6 b(t)85 b(I)6 b(I)p Fx(:)73
+ b(If)f(instructions)f(are)i(b)5 b(eing)72 b(ejected)f(to)5
+ b(o)73 b(man)-5 b(y)72 b(times,)i(all)e(are)h(remo)-5
+ b(v)g(ed)72 b(from)g(the)455 6052 y(sc)-5 b(hedule,)49
+ b(and)g(I)5 b(I)48 b(is)h(incremen)-5 b(ted.)74 b(The)49
+ b(Slac)-5 b(k)49 b(sc)-5 b(heduling)47 b(steps)h(are)h(then)f(rep)5
+ b(eated)49 b(un)-5 b(til)47 b(a)i(sc)-5 b(hedule)455
+ 6417 y(is)59 b(found)h(or)h(the)f(algorithm)f(giv)-5
+ b(es)60 b(up.)282 6882 y(According)88 b(to)g(a)g(study)g([10)o(])g
+ (that)g(compared)g(v)-10 b(arious)87 b(mo)5 b(dulo)87
+ b(sc)-5 b(heduling)87 b(approac)-5 b(hes,)94 b(Slac)-5
+ b(k)87 b(did)0 7247 y(appro)-5 b(ximately)78 b(the)i(same)f(as)h(SMS)f
+ (in)h(reducing)g(register)f(pressure)g(on)h(all)g(t)-5
+ b(yp)5 b(es)79 b(of)h(arc)-5 b(hitectures,)82 b(but)0
+ 7613 y(required)53 b(m)-5 b(uc)g(h)53 b(more)h(compile)d(time.)77
+ b(SMS)53 b(is)g(usually)g(able)g(to)g(compute)g(a)h(b)5
+ b(etter)53 b(sc)-5 b(hedule)52 b(then)h(Slac)-5 b(k)53
+ b(for)0 7978 y(arc)-5 b(hitectures)44 b(of)i(lo)-5 b(w)1524
+ 7912 y Fo(3)1649 7978 y Fx(and)46 b(medium)2626 7912
+ y Fo(4)2749 7978 y Fx(complexit)-5 b(y)44 b(and)i(Slac)-5
+ b(k)46 b(w)-5 b(as)46 b(also)f(b)5 b(eat)46 b(b)-5 b(y)46
+ b(IMS)g(on)g(higher)f(complexit)-5 b(y)0 8343 y(arc)g(hitectures.)0
+ 8965 y Fk(3.1.3)225 b(In)-6 b(tegrated)74 b(Register)i(Sensitiv)-6
+ b(e)76 b(Iterativ)-6 b(e)76 b(Soft)-6 b(w)g(are)74 b(Pip)6
+ b(elining)0 9447 y Fu(In)-5 b(tegrated)57 b(Register)f(Sensitiv)-5
+ b(e)56 b(Iterativ)-5 b(e)57 b(Soft)-5 b(w)g(are)57 b
+ Fx([12)o(])h(\(IRIS\))f(Pip)5 b(elining)55 b(uses)j(an)g(in)-5
+ b(tegrated)56 b(approac)-5 b(h)0 9813 y(comp)5 b(osed)51
+ b(of)h(mo)5 b(di\014ed)51 b(heuristics)f(prop)5 b(osed)52
+ b(in)g(Stage)g(Sc)-5 b(heduling)50 b([17])i(and)g(Rau's)f(iterativ)-5
+ b(e)50 b(metho)5 b(d)52 b([33)o(].)p 0 9961 3120 7 v
+ 207 10069 a Fl(3)276 10132 y Fs(Lo)l(w)45 b(complexit)l(y)f(arc)l
+ (hitectures)h(are)h(those)e(with)h(fully)f(pip)t(elined)i(instructions)
+ e(with)h(3)g(in)l(teger)g(and)g(3)g(\015oating)f(p)t(oin)l(t)h(units,)0
+ 10315 y(and)52 b(issue)e(width)h(of)g(8)g(instructions)g([10)o(].)207
+ 10434 y Fl(4)276 10497 y Fs(Medium)i(complexit)l(y)f(arc)l(hitectures)g
+ (ha)l(v)l(e)g(fully)g(pip)t(elined)h(instructions,)e(but)i(only)f(2)f
+ (in)l(teger)h(and)h(2)f(\015oating)f(p)t(oin)l(t)h(units)0
+ 10680 y(and)g(an)f(issue)g(width)g(of)g(4)g(instructions)f([10)o(].)
+ 3809 11136 y Fx(13)p eop end
+ %%Page: 14 21
+ TeXDict begin 14 20 bop 0 183 a Fx(This)66 b(approac)-5
+ b(h)66 b(aims)f(to)h(ac)-5 b(hiev)g(e)65 b(a)i(high)f(initiation)d
+ (rate)j(while)g(main)-5 b(taining)64 b(lo)-5 b(w)66 b(register)f
+ (requiremen)-5 b(ts.)0 548 y(IRIS)60 b(is)g(a)g(bidirectional)e
+ (strategy)i(and)g(sc)-5 b(hedules)59 b(instructions)g(as)h(early)g(or)h
+ (as)f(late)f(as)i(p)5 b(ossible.)282 913 y(IRIS)60 b(is)g(similar)e(to)
+ j(IMS,)e(describ)5 b(ed)60 b(in)g(Section)f(3.1.1,)g(but)h(con)-5
+ b(tains)59 b(the)h(follo)-5 b(wing)59 b(mo)5 b(di\014cations:)273
+ 1478 y Fr(\017)91 b Fx(Earliest)73 b(start)i(\()p Fp(est)-12
+ b(ar)g(t)p Fx(\))77 b(and)e(latest)f(start)h(\()p Fp(lst)-12
+ b(ar)g(t)p Fx(\))76 b(are)g(calculated)d(as)j(describ)5
+ b(ed)74 b(b)-5 b(y)76 b(the)f(Slac)-5 b(k)455 1843 y(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling)59 b(algorithm)g([21)o(].)80
+ b(This)60 b(creates)g(a)h(tigh)-5 b(ter)59 b(b)5 b(ound)61
+ b(on)f Fp(lst)-12 b(ar)g(t)p Fx(.)273 2358 y Fr(\017)91
+ b Fx(Instructions)55 b(are)i(placed)f(as)h(early)f(or)h(as)g(late)f(as)
+ h(p)5 b(ossible)55 b(in)i(the)g(sc)-5 b(hedule,)56 b(whic)-5
+ b(h)56 b(is)h(determined)e(b)-5 b(y)455 2724 y(using)61
+ b(mo)5 b(di\014ed)62 b(Stage)g(Sc)-5 b(heduling)61 b([17)o(])i
+ (heuristics.)84 b(The)63 b(searc)-5 b(h)62 b(for)g(an)h(optimal)d
+ (issue)i(slot)f(is)h(done)455 3089 y(from)d Fp(est)-12
+ b(ar)g(t)62 b Fx(to)f Fp(lst)-12 b(ar)g(t)p Fx(,)61 b(or)g(vice-v)-5
+ b(ersa.)282 3654 y(IRIS)88 b(is)h(iden)-5 b(tical)86
+ b(to)j(IMS)f(in)h(that)f(it)g(uses)g(the)h(same)f(heigh)-5
+ b(t-based)87 b(priorit)-5 b(y)87 b(function,)95 b(the)88
+ b(same)0 4019 y(thresholds)h(to)h(determine)e(when)j(a)f(sc)-5
+ b(hedule)89 b(should)g(b)5 b(e)90 b(discarded)f(and)i(I)5
+ b(I)89 b(increased,)96 b(and)90 b(the)g(same)0 4384 y(tec)-5
+ b(hnique)59 b(to)h(eject)g(instructions)e(from)i(the)g(sc)-5
+ b(hedule.)282 4750 y(This)62 b(algorithm)f(di\013ers)g(mainly)g(in)h
+ (its)f(use)h(of)g(mo)5 b(di\014ed)61 b(Stage)h(Sc)-5
+ b(heduling)61 b([17)o(])h(heuristics,)e(whic)-5 b(h)62
+ b(are)0 5115 y(used)80 b(to)h(determine)e(whic)-5 b(h)80
+ b(direction)g(to)g(searc)-5 b(h)81 b(for)f(a)h(con\015ict-free)d(issue)
+ i(slot.)140 b(The)81 b(heuristics)e(are)h(as)0 5480 y(follo)-5
+ b(ws:)222 6045 y(1.)91 b(If)c(the)h(instruction)e(is)h(a)i(source)e(no)
+ 5 b(de)88 b(in)g(the)g(DDG,)f(the)h(partial)f(sc)-5 b(hedule)86
+ b(is)i(searc)-5 b(hed)87 b(for)h(an)-5 b(y)455 6410 y(successors.)85
+ b(If)62 b(one)g(or)h(more)f(exist,)g(the)g(algorithm)f(searc)-5
+ b(hes)62 b(from)g Fp(lst)-12 b(ar)g(t)64 b Fx(to)e Fp(est)-12
+ b(ar)g(t)64 b Fx(for)f(an)f(issue)455 6776 y(slot.)222
+ 7291 y(2.)91 b(If)57 b(the)g(instruction)f(is)i(a)f(sink)h(no)5
+ b(de)57 b(in)h(the)f(DDG,)g(and)h(only)g(has)f(predecessors)g(in)g(the)
+ h(sc)-5 b(hedule,)56 b(then)455 7656 y(the)k(searc)-5
+ b(h)60 b(for)g(an)h(issue)e(slot)g(b)5 b(egins)60 b(from)g
+ Fp(est)-12 b(ar)g(t)62 b Fx(to)e Fp(lst)-12 b(ar)g(t)p
+ Fx(.)222 8171 y(3.)91 b(If)73 b(this)g(instruction)f(has)i(only)g
+ (successors)e(in)i(the)g(partial)e(sc)-5 b(hedule,)76
+ b(and)e(forms)f(a)h(cut)g(edge)7240 8105 y Fo(5)7318
+ 8171 y Fx(,)j(then)455 8536 y(the)i(sc)-5 b(hedule)79
+ b(is)g(scanned)g(from)g Fp(lst)-12 b(ar)g(t)81 b Fx(to)f
+ Fp(est)-12 b(ar)g(t)81 b Fx(for)f(an)g(op)5 b(en)80 b(time)e(slot,)83
+ b(and)d(vice-v)-5 b(ersa)78 b(for)455 8902 y(predecessors.)222
+ 9416 y(4.)91 b(If)51 b(an)i(instruction)e(do)5 b(es)52
+ b(not)g(fall)f(in)-5 b(to)52 b(an)-5 b(y)53 b(of)f(the)g(categories)f
+ (ab)5 b(o)-5 b(v)g(e,)53 b(it)f(b)5 b(egins)52 b(searc)-5
+ b(hing)51 b(for)i(an)f(issue)455 9782 y(slot)59 b(from)h
+ Fp(est)-12 b(ar)g(t)62 b Fx(and)e(ends)g(with)h Fp(lst)-12
+ b(ar)g(t)p Fx(.)p 0 9905 3120 7 v 207 10012 a Fl(5)276
+ 10076 y Fs(A)48 b(cut)g(edge)g(is)e(an)i(edge)g(whose)f(remo)l(v)-9
+ b(al)47 b(from)g(a)h(graph)f(pro)t(duces)i(a)e(subgraph)h(with)f(more)g
+ (comp)t(onen)l(ts)h(than)g(the)f(original)0 10258 y(graph.)3809
+ 11136 y Fx(14)p eop end
+ %%Page: 15 22
+ TeXDict begin 15 21 bop 282 183 a Fx(According)59 b(to)f(the)g
+ (comparativ)-5 b(e)57 b(study)h([10],)g(b)5 b(oth)58
+ b(IRIS)g(and)h(IMS)f(do)g(fairly)g(w)-5 b(ell,)57 b(in)i(terms)e(of)i
+ (\014nding)0 548 y(an)66 b(optimal)e(sc)-5 b(hedule,)65
+ b(on)h(complex)f(arc)-5 b(hitectures)64 b(since)h(they)g(are)h(b)5
+ b(oth)66 b(iterativ)-5 b(e)64 b(tec)-5 b(hniques.)94
+ b(Ho)-5 b(w)g(ev)g(er,)0 913 y(IRIS)55 b(w)-5 b(as)56
+ b(least)e(e\013ectiv)-5 b(e)54 b(in)i(terms)f(of)g(register)g
+ (requiremen)-5 b(ts)54 b(when)i(compared)f(against)f(SMS)i(for)f(all)g
+ (t)-5 b(yp)5 b(es)0 1279 y(of)60 b(arc)-5 b(hitectures.)0
+ 1907 y Fk(3.1.4)225 b(Hyp)6 b(erno)g(de)74 b(Reduction)g(Mo)6
+ b(dulo)74 b(Sc)-6 b(heduling)0 2390 y Fu(Hyp)5 b(erno)g(de)51
+ b(Reduction)f(Mo)5 b(dulo)50 b(Sc)-5 b(heduling)50 b
+ Fx([28)o(])h(\(HRMS\))g(is)f(another)h(bidirectional)d(tec)-5
+ b(hnique)50 b(that)h(uses)0 2755 y(an)83 b(ordering)g(phase)g(to)g
+ (select)f(the)h(order)g(in)g(whic)-5 b(h)83 b(instructions)e(are)i(sc)
+ -5 b(heduled.)148 b(HRMS)83 b(attempts)e(to)0 3120 y(shorten)60
+ b(the)g(lifetime)e(of)i(lo)5 b(op)60 b(v)-10 b(arian)-5
+ b(ts)59 b(without)h(sacri\014cing)f(p)5 b(erformance.)282
+ 3486 y(Lik)-5 b(e)80 b(other)h(Mo)5 b(dulo)80 b(Sc)-5
+ b(heduling)79 b(approac)-5 b(hes,)85 b(HRMS)c(computes)e(the)i(MI)5
+ b(I)80 b(from)g(the)h(resource)f(and)0 3851 y(recurrence)64
+ b(constrain)-5 b(ts)63 b(and)h(creates)g(a)g(data)g(dep)5
+ b(endence)64 b(graph)g(for)g(the)g(program.)92 b(HRMS)64
+ b(is)g(unique)f(in)0 4217 y(ho)-5 b(w)65 b(it)e(orders)i(the)f
+ (instructions)e(to)i(b)5 b(e)65 b(sc)-5 b(heduled.)90
+ b(The)65 b(ordering)f(phase)g(guaran)-5 b(tees)63 b(an)i(instruction)d
+ (will)0 4582 y(only)53 b(ha)-5 b(v)g(e)54 b(predecessors)f(or)h
+ (successors)e(in)i(the)g(partial)e(sc)-5 b(hedule:)76
+ b(The)54 b(only)g(exception)e(are)i(recurrences,)g(to)0
+ 4947 y(whic)-5 b(h)60 b(ha)-5 b(v)g(e)60 b(priorit)-5
+ b(y)-15 b(.)80 b(The)60 b(ordering)g(phase)h(is)e(only)h(p)5
+ b(erformed)60 b(once,)g(ev)-5 b(en)60 b(if)f(I)5 b(I)60
+ b(increases.)282 5313 y(The)48 b(ordering)e(phase)h(is)f(an)h(iterativ)
+ -5 b(e)46 b(algorithm)f(and)i(for)g(eac)-5 b(h)47 b(iteration)e(the)i
+ (neigh)-5 b(b)5 b(ors)46 b(of)h(a)g Fu(Hyp)5 b(erno)g(de)0
+ 5678 y Fx(are)42 b(ordered,)j(and)d(then)g(reduced)g(in)-5
+ b(to)41 b(a)h(new)g(Hyp)5 b(erno)g(de.)74 b(A)43 b(Hyp)5
+ b(erno)g(de)42 b(is)f(a)h(single)f(no)5 b(de)42 b(that)f(represen)-5
+ b(ts)41 b(a)0 6043 y(no)5 b(de)49 b(or)g(subgraph)g(of)g(the)f(DDG.)g
+ (The)i(ordering)e(pass)h(is)f(easily)g(explained)f(for)i(graphs)g
+ (without)f(recurrences.)0 6409 y(The)69 b(basic)e(algorithm)g(will)h(b)
+ 5 b(e)68 b(presen)-5 b(ted)68 b(\014rst,)i(and)e(then)g(the)h(mo)5
+ b(di\014cations)66 b(made)i(for)g(recurrences)g(will)0
+ 6774 y(b)5 b(e)60 b(discussed.)282 7140 y(F)-15 b(or)51
+ b(a)g(graph)g(without)f(recurrences,)i(the)e(initial)f(Hyp)5
+ b(erno)g(de)51 b(ma)-5 b(y)50 b(b)5 b(e)51 b(the)f(\014rst)h(no)5
+ b(de)51 b(or)g(an)-5 b(y)50 b(no)5 b(de)51 b(in)f(the)0
+ 7505 y(DDG.)j(The)h(predecessors)f(and)h(successors)e(of)i(a)f(Hyp)5
+ b(erno)g(de)55 b(are)f(alternativ)-5 b(ely)51 b(ordered)j(with)f(the)h
+ (follo)-5 b(wing)0 7870 y(steps:)222 8420 y(1.)91 b(The)60
+ b(no)5 b(des)60 b(on)h(all)e(paths)h(b)5 b(et)-5 b(w)g(een)60
+ b(the)h(predecessors/successors)c(are)k(collected.)222
+ 8930 y(2.)91 b(The)56 b(predecessor/successor)e(no)5
+ b(des)56 b(from)g(the)g(previous)f(step)h(and)g(the)g(Hyp)5
+ b(erno)g(de)57 b(are)f(reduced)g(in)-5 b(to)455 9295
+ y(a)60 b(new)h(Hyp)5 b(erno)g(de.)222 9805 y(3.)91 b(A)60
+ b(top)5 b(ological)57 b(sort)i(is)g(done)h(on)f(the)h(subgraph)f(that)g
+ (the)g(Hyp)5 b(erno)g(de)60 b(represen)-5 b(ts,)59 b(and)g(the)h
+ (resulting)455 10170 y(sorted)g(list)f(is)g(app)5 b(ended)61
+ b(to)f(the)g(\014nal)g(ordered)h(list.)222 10680 y(4.)91
+ b(The)60 b(steps)g(are)g(rep)5 b(eated)60 b(un)-5 b(til)60
+ b(the)g(graph)g(is)g(reduced)g(to)h(a)f(single)f(Hyp)5
+ b(erno)g(de.)3809 11136 y(15)p eop end
+ %%Page: 16 23
+ TeXDict begin 16 22 bop 282 183 a Fx(Graphs)49 b(with)f(recurrences)g
+ (are)h(pro)5 b(cessed)48 b(\014rst)h(b)-5 b(y)48 b(the)h(ordering)f
+ (phase,)i(and)f(no)g(single)e(no)5 b(de)49 b(is)f(selected)0
+ 548 y(as)81 b(the)g(initial)e(Hyp)5 b(erno)g(de.)144
+ b(The)81 b(recurrences)g(are)g(\014rst)h(sorted)e(according)h(to)g
+ (their)g(RecMI)5 b(I,)79 b(with)i(the)0 913 y(highest)75
+ b(RecMI)5 b(I)74 b(ha)-5 b(ving)75 b(priorit)-5 b(y)-15
+ b(,)79 b(resulting)74 b(in)i(a)f(list)g(of)g(sets)g(of)h(no)5
+ b(des)75 b(\(eac)-5 b(h)75 b(set)h(is)f(a)h(recurrence\).)126
+ b(If)0 1279 y(an)-5 b(y)73 b(recurrence)f(shares)g(the)h(same)f(bac)-5
+ b(k)72 b(edge)h(as)f(another,)j(the)d(sets)g(are)h(merged)f(together)g
+ (in)-5 b(to)72 b(the)g(one)0 1644 y(with)82 b(the)h(highest)e(priorit)
+ -5 b(y)-15 b(.)145 b(If)82 b(an)-5 b(y)83 b(no)5 b(de)82
+ b(is)g(in)h(more)f(than)g(one)h(set,)k(it)82 b(is)g(remo)-5
+ b(v)g(ed)81 b(from)h(all)g(but)g(the)0 2010 y(recurrence)65
+ b(with)g(the)g(highest)f(RecMI)5 b(I.)63 b(Instead)h(of)h(ordering)g
+ (predecessors)f(and)h(successors)f(alternativ)-5 b(ely)0
+ 2375 y(to)52 b(this)g(Hyp)5 b(erno)g(de,)54 b(the)e(ordering)g(phase)g
+ (do)5 b(es)52 b(the)g(follo)-5 b(wing,)52 b(b)5 b(eginning)51
+ b(with)i(the)f(\014rst)g(recurrence)g(in)g(the)0 2740
+ y(list:)222 3305 y(1.)91 b(Find)64 b(all)h(the)g(no)5
+ b(des)65 b(from)g(the)g(curren)-5 b(t)65 b(recurrence)g(to)g(the)g
+ (next)g(in)g(the)g(list.)94 b(This)65 b(is)g(done)g(with)g(all)455
+ 3670 y(bac)-5 b(k)60 b(edges)g(remo)-5 b(v)g(ed)59 b(in)h(order)h(to)f
+ (prev)-5 b(en)g(t)60 b(cycles.)222 4185 y(2.)91 b(Reduce)45
+ b(the)h(recurrence,)j(the)c(no)5 b(des)46 b(collected)f(from)g(the)h
+ (previous)g(step,)i(and)e(the)g(curren)-5 b(t)46 b(Hyp)5
+ b(erno)g(de)455 4550 y(\(if)59 b(there)h(is)g(one\),)f(in)-5
+ b(to)60 b(a)h(new)f(Hyp)5 b(erno)g(de.)222 5065 y(3.)91
+ b(P)-5 b(erform)63 b(a)i(top)5 b(ological)63 b(sort)h(on)h(the)g
+ (subgraph)f(that)h(the)f(Hyp)5 b(erno)g(de)65 b(represen)-5
+ b(ts,)65 b(and)g(app)5 b(end)64 b(the)455 5431 y(no)5
+ b(des)60 b(to)g(the)g(\014nal)g(ordered)h(list.)222 5945
+ y(4.)91 b(Rep)5 b(eat)63 b(the)i(ab)5 b(o)-5 b(v)g(e)64
+ b(steps)g(un)-5 b(til)63 b(the)h(graph)h(is)f(reduced)g(to)h(one)f
+ (without)g(recurrences,)h(and)f(then)g(use)455 6311 y(the)c(algorithm)e
+ (describ)5 b(ed)60 b(for)g(graphs)h(without)e(recurrences.)282
+ 6875 y(The)53 b(sc)-5 b(heduling)50 b(phase)i(of)g(HRMS)g(uses)f(the)h
+ (\014nal)g(ordered)g(list)f(and)h(attempts)e(to)i(sc)-5
+ b(hedule)51 b(instructions)0 7241 y(as)57 b(close)g(as)g(p)5
+ b(ossible)56 b(to)h(their)g(predecessors)f(and)h(successors)f(already)h
+ (in)g(the)g(partial)g(sc)-5 b(hedule.)78 b(It)57 b(uses)f(the)0
+ 7606 y(same)47 b(calculations)f(for)h(the)h(start)g(and)g(end)g(cycles)
+ e(that)i(SMS)g(do)5 b(es,)49 b(whic)-5 b(h)48 b(will)f(b)5
+ b(e)48 b(discussed)f(in)g(Section)g(4.6.)0 7972 y(If)59
+ b(there)g(are)h(no)f(free)h(slots)e(for)h(the)g(instruction,)f(the)h
+ (sc)-5 b(hedule)59 b(is)f(cleared,)h(I)5 b(I)59 b(is)g(increased,)f
+ (and)i(sc)-5 b(heduling)0 8337 y(b)5 b(egins)60 b(again.)282
+ 8702 y(HRMS)88 b(is)g(the)g(algorithm)e(that)i(has)g(the)g(most)f(in)h
+ (common)f(with)h(SMS.)f(They)i(b)5 b(oth)88 b(\014nd)g(optimal)0
+ 9068 y(sc)-5 b(hedules)61 b(in)i(a)g(reasonable)e(amoun)-5
+ b(t)62 b(of)h(compile)e(time.)86 b(Ho)-5 b(w)g(ev)g(er,)63
+ b(b)5 b(ecause)62 b(they)h(di\013er)f(in)h(ho)-5 b(w)63
+ b(the)f(no)5 b(des)0 9433 y(are)52 b(ordered)h(for)f(sc)-5
+ b(heduling)51 b(\(HRMS)h(do)5 b(es)52 b(not)g(tak)-5
+ b(e)52 b(in)-5 b(to)52 b(consideration)f(the)h(criticalit)-5
+ b(y)49 b(of)j(no)5 b(des\),)53 b(HRMS)0 9798 y(is)60
+ b(not)g(as)g(successful)f(as)h(SMS)g(in)g(ac)-5 b(hieving)59
+ b(lo)-5 b(w)60 b(register)g(pressure.)3809 11136 y(16)p
+ eop end
+ %%Page: 17 24
+ TeXDict begin 17 23 bop 0 183 a Ft(3.2)270 b(Global)90
+ b(Mo)7 b(dulo)92 b(Sc)-7 b(heduling)0 728 y Fx(While)79
+ b(Mo)5 b(dulo)80 b(Sc)-5 b(heduling)79 b(is)g(an)i(e\013ectiv)-5
+ b(e)79 b(tec)-5 b(hnique)79 b(for)h(sc)-5 b(heduling)79
+ b(lo)5 b(op)79 b(in)-5 b(tensiv)g(e)79 b(programs,)84
+ b(it)c(is)0 1093 y(limited)61 b(to)i(single)e(basic)h(blo)5
+ b(c)-5 b(k)63 b(lo)5 b(ops)62 b(\(without)g(con)-5 b(trol)62
+ b(\015o)-5 b(w\).)88 b(These)63 b(restrictions)e(cause)h(man)-5
+ b(y)63 b(Soft)-5 b(w)g(are)0 1459 y(Pip)5 b(elining)74
+ b(opp)5 b(ortunities)74 b(on)j(complex)e(lo)5 b(ops)75
+ b(to)h(b)5 b(e)76 b(missed.)126 b(Therefore,)80 b(a)c(family)e(of)i
+ (tec)-5 b(hniques)75 b(that)0 1824 y(w)-5 b(ork)61 b(on)f(complex)g(lo)
+ 5 b(ops,)59 b(called)g Fu(Global)g(Mo)5 b(dulo)60 b(Sc)-5
+ b(heduling)59 b Fx(emerged.)282 2190 y(As)79 b(men)-5
+ b(tioned)76 b(previously)-15 b(,)81 b(there)c(are)h(t)-5
+ b(w)g(o)78 b(groups)g(of)g(Sc)-5 b(hedule-then-Mo)g(v)g(e)75
+ b(tec)-5 b(hniques:)114 b(Unrolling)0 2555 y(based,)60
+ b(and)h(Mo)5 b(dulo)60 b(Sc)-5 b(heduling.)79 b(There)61
+ b(are)g(sev)-5 b(eral)60 b(unrolling)f(based)i(global)e(Soft)-5
+ b(w)g(are)61 b(Pip)5 b(elining)58 b(tec)-5 b(h-)0 2920
+ y(niques)66 b(that)g(are)h(able)g(to)f(handle)g(lo)5
+ b(ops)67 b(with)f(con)-5 b(trol)66 b(\015o)-5 b(w:)94
+ b(P)-5 b(erfect)65 b(Pip)5 b(elining)65 b([2)o(],)j(GURPR*)e([38)o(],)i
+ (and)0 3286 y(Enhanced)60 b(Pip)5 b(elining)57 b([15].)79
+ b(Since)60 b(the)f(fo)5 b(cus)60 b(of)f(this)h(thesis)e(is)i(on)g(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling,)58 b(these)i(tec)-5 b(hniques)0
+ 3651 y(will)59 b(not)i(b)5 b(e)60 b(discussed.)282 4016
+ y(Global)k(Mo)5 b(dulo)64 b(Sc)-5 b(heduling)63 b(approac)-5
+ b(hes)64 b(are)h(t)-5 b(ypically)63 b(tec)-5 b(hniques)63
+ b(that)h(transform)f(a)i(complex)f(lo)5 b(op)0 4382 y(in)-5
+ b(to)46 b(a)g(single)f(basic)h(blo)5 b(c)-5 b(k)46 b(of)g(straigh)-5
+ b(t)45 b(line)h(co)5 b(de,)48 b(and)f(then)f(p)5 b(erform)46
+ b(Mo)5 b(dulo)46 b(Sc)-5 b(heduling)45 b(as)h(normal.)75
+ b(Co)5 b(de)0 4747 y(generation)52 b(is)h(sligh)-5 b(tly)52
+ b(more)h(c)-5 b(hallenging)51 b(as)j(the)f(original)f(con)-5
+ b(trol)53 b(\015o)-5 b(w)54 b(needs)f(to)g(b)5 b(e)54
+ b(reconstructed)e(within)0 5113 y(the)61 b(new)g(pip)5
+ b(elined)59 b(lo)5 b(op.)81 b(There)61 b(are)g(t)-5 b(w)g(o)61
+ b(w)-5 b(ell)60 b(kno)-5 b(wn)61 b(tec)-5 b(hniques)59
+ b(for)i(transforming)e(complex)h(lo)5 b(ops)60 b(in)-5
+ b(to)0 5478 y(straigh)g(t)77 b(line)f(co)5 b(de:)115
+ b(Hierarc)-5 b(hical)77 b(Reduction)f([25])h(\(describ)5
+ b(ed)77 b(in)g(Section)g(3.2.1\))g(and)h(If-con)-5 b(v)g(ersion)75
+ b([3)o(])0 5843 y(\(describ)5 b(ed)71 b(in)g(Section)g(3.2.2\).)113
+ b(Last,)73 b(Enhanced)f(Mo)5 b(dulo)71 b(Sc)-5 b(heduling)70
+ b([41])h(builds)g(o\013)h(the)g(ideas)f(b)5 b(ehind)0
+ 6209 y(If-con)-5 b(v)g(ersion)58 b(and)j(Hierarc)-5 b(hical)59
+ b(Reduction.)0 6839 y Fk(3.2.1)225 b(Hierarc)-6 b(hical)74
+ b(Reduction)0 7322 y Fu(Hierarc)-5 b(hical)85 b(Reduction)h
+ Fx([25)o(])h(is)f(a)h(tec)-5 b(hnique)85 b(to)i(transform)e(lo)5
+ b(ops)86 b(with)h(conditional)d(statemen)-5 b(ts)85 b(in)-5
+ b(to)0 7687 y(straigh)g(t)83 b(line)g(co)5 b(de)85 b(whic)-5
+ b(h)84 b(can)g(then)g(b)5 b(e)84 b(mo)5 b(dulo)84 b(sc)-5
+ b(heduled)83 b(using)g(an)-5 b(y)85 b(of)f(the)g(tec)-5
+ b(hniques)82 b(previously)0 8053 y(discussed.)138 b(The)81
+ b(main)e(idea)h(is)g(to)g(represen)-5 b(t)80 b(all)f(the)h(con)-5
+ b(trol)79 b(constructs)h(as)g(a)g(single)f(instruction,)k(and)0
+ 8418 y(sc)-5 b(hedule)71 b(this)h(lik)-5 b(e)71 b(an)-5
+ b(y)72 b(other)g(instruction.)115 b(Lam)71 b(mo)5 b(deled)71
+ b(her)i(tec)-5 b(hnique)71 b(after)h(a)g(previous)g(sc)-5
+ b(heduling)0 8784 y(tec)g(hnique)69 b(b)-5 b(y)71 b(W)-15
+ b(o)5 b(o)g(d)70 b([42)o(],)i(where)f(conditional)d(statemen)-5
+ b(ts)69 b(w)-5 b(ere)70 b(mo)5 b(deled)70 b(as)g(blac)-5
+ b(k)69 b(b)5 b(o)-5 b(xes)70 b(taking)g(some)0 9149 y(amoun)-5
+ b(t)89 b(of)g(time,)95 b(but)90 b(further)f(re\014ned)g(it)g(so)h(the)f
+ (actual)g(resource)g(constrain)-5 b(ts)88 b(w)-5 b(ould)89
+ b(b)5 b(e)90 b(tak)-5 b(en)89 b(in)-5 b(to)0 9514 y(consideration.)282
+ 9880 y(Hierarc)g(hical)71 b(reduction)h(has)g(three)h(main)e(b)5
+ b(ene\014ts.)116 b(First,)74 b(it)e(remo)-5 b(v)g(es)71
+ b(conditional)g(statemen)-5 b(ts)70 b(as)i(a)0 10245
+ y(barrier)83 b(to)f(Mo)5 b(dulo)82 b(Sc)-5 b(heduling.)145
+ b(Second,)87 b(more)c(complex)e(lo)5 b(ops)82 b(are)g(exp)5
+ b(osed)83 b(that)f(t)-5 b(ypically)80 b(con)-5 b(tain)0
+ 10610 y(a)77 b(signi\014can)-5 b(t)75 b(amoun)-5 b(t)76
+ b(of)g(parallelism.)126 b(Finally)-15 b(,)79 b(it)d(diminishes)e(the)i
+ (p)5 b(enalt)-5 b(y)76 b(for)h(lo)5 b(ops)76 b(that)g(ha)-5
+ b(v)g(e)76 b(short)3809 11136 y(17)p eop end
+ %%Page: 18 25
+ TeXDict begin 18 24 bop 0 183 a Fx(execution)83 b(times)f(b)5
+ b(ecause)84 b(it)f(exp)5 b(oses)84 b(the)f(opp)5 b(ortunit)-5
+ b(y)84 b(to)g(mo)5 b(dulo)83 b(sc)-5 b(hedule)83 b(outer)h(lo)5
+ b(ops)83 b(that)h(could)0 548 y(con)-5 b(tain)59 b(these)h(short)g
+ (inner)g(lo)5 b(ops.)80 b(Hierarc)-5 b(hical)59 b(reduction)g(requires)
+ h(no)h(sp)5 b(ecial)59 b(hardw)-5 b(are)61 b(supp)5 b(ort.)282
+ 913 y(This)66 b(tec)-5 b(hnique)64 b(sc)-5 b(hedules)65
+ b(the)g(program)h(hierarc)-5 b(hically)64 b(starting)g(with)i(the)f
+ (inner)h(most)f(con)-5 b(trol)65 b(con-)0 1279 y(structs.)74
+ b(After)46 b(sc)-5 b(heduling)45 b(the)g(construct,)j(it)d(is)h
+ (reduced)g(to)f(a)h(single)f(no)5 b(de)46 b(that)g(represen)-5
+ b(ts)45 b(all)g(the)h(resource)0 1644 y(constrain)-5
+ b(ts)67 b(of)i(its)f(comp)5 b(onen)-5 b(ts.)104 b(A)70
+ b(program)f(is)f(successfully)e(sc)-5 b(heduled)68 b(after)g(it)h(is)f
+ (reduced)h(to)g(a)g(single)0 2010 y(no)5 b(de.)80 b(The)61
+ b(Hierarc)-5 b(hical)59 b(Reduction)g(tec)-5 b(hnique)59
+ b(is)h(describ)5 b(ed)60 b(in)g(detail)f(in)h(the)g(follo)-5
+ b(wing)59 b(steps:)222 2501 y(1.)91 b(The)73 b(instructions)e(corresp)5
+ b(onding)73 b(to)g(the)g Fp(then)g Fx(and)g Fp(else)i
+ Fx(branc)-5 b(hes)73 b(of)g(a)g(conditional)e(statemen)-5
+ b(t)455 2866 y(are)60 b(sc)-5 b(heduled)59 b(indep)5
+ b(enden)-5 b(tly)-15 b(.)222 3356 y(2.)91 b(All)47 b(sc)-5
+ b(heduling)46 b(constrain)-5 b(ts)46 b(are)i(captured)g(b)-5
+ b(y)48 b(examining)e(the)h(mo)5 b(dulo)47 b(reserv)-10
+ b(ation)47 b(table)g(and)h(taking)455 3722 y(the)i(maxim)-5
+ b(um)49 b(of)h(all)g(the)h(en)-5 b(tries)50 b(for)g(the)h(t)-5
+ b(w)g(o)51 b(branc)-5 b(hes.)76 b(A)51 b(no)5 b(de)51
+ b(is)f(created)h(to)f(represen)-5 b(t)50 b(the)h(en)-5
+ b(tire)455 4087 y(conditional)58 b(statemen)-5 b(t.)222
+ 4578 y(3.)91 b(The)59 b(data)f(dep)5 b(endence)59 b(graph)g(is)f(up)5
+ b(dated)58 b(b)-5 b(y)59 b(replacing)f(all)g(the)h(instructions)e(that)
+ h(are)h(represen)-5 b(ted)455 4943 y(b)g(y)56 b(this)g(new)h(no)5
+ b(de,)57 b(and)g(the)f(dep)5 b(endences)56 b(are)h(preserv)-5
+ b(ed)56 b(b)5 b(et)-5 b(w)g(een)56 b(what)h(this)f(no)5
+ b(de)56 b(represen)-5 b(ts)56 b(and)455 5308 y(other)k(instructions.)
+ 222 5799 y(4.)91 b(Finally)-15 b(,)56 b(the)i(steps)f(are)i(rep)5
+ b(eated)57 b(un)-5 b(til)57 b(the)h(whole)g(program)g(has)g(b)5
+ b(een)59 b(sc)-5 b(heduled)57 b(and)h(reduced)g(to)g(a)455
+ 6164 y(single)h(no)5 b(de.)282 6655 y(Hierarc)-5 b(hical)51
+ b(Reduction)f(do)5 b(es)52 b(require)f(some)g(c)-5 b(hanges)52
+ b(to)f(co)5 b(de)52 b(generation)f(of)g(the)h(new)g(pip)5
+ b(elined)50 b(lo)5 b(op.)0 7021 y(F)-15 b(or)84 b(co)5
+ b(de)85 b(sc)-5 b(heduled)83 b(in)h(parallel)f(with)i(the)f
+ (conditional)f(statemen)-5 b(t,)88 b(that)c(co)5 b(de)84
+ b(is)g(duplicated)f(in)h(b)5 b(oth)0 7386 y(branc)-5
+ b(hes.)78 b(It)55 b(is)g(imp)5 b(ortan)-5 b(t)54 b(to)h(note)g(that)g
+ (while)g(Hierarc)-5 b(hical)54 b(Reduction)h(do)5 b(es)55
+ b(successfully)e(represen)-5 b(t)54 b(the)0 7751 y(recurrence)61
+ b(constrain)-5 b(ts)59 b(of)i(conditional)e(constructs,)g(it)i(do)5
+ b(es)60 b(tak)-5 b(e)61 b(the)g(w)-5 b(orst)61 b(case)f(as)h(its)f(v)
+ -10 b(alue.)81 b(Ho)-5 b(w)g(ev)g(er,)0 8117 y(this)60
+ b(ma)-5 b(y)59 b(not)i(b)5 b(e)60 b(the)g(path)h(most)e(tak)-5
+ b(en)60 b(in)g(the)g(lo)5 b(op,)60 b(and)g(the)g(resulting)f(I)5
+ b(I)60 b(ma)-5 b(y)60 b(not)h(b)5 b(e)60 b(truly)g(optimal.)0
+ 8736 y Fk(3.2.2)225 b(If-Con)-6 b(v)g(ersion)0 9218 y
+ Fu(If-con)h(v)g(ersion)57 b Fx(is)i(another)g(tec)-5
+ b(hnique)58 b(for)h(transforming)e(lo)5 b(ops)59 b(with)g(conditional)e
+ (statemen)-5 b(ts)57 b(in)-5 b(to)58 b(straigh)-5 b(t)0
+ 9584 y(line)55 b(co)5 b(de.)78 b(The)56 b(idea)f(is)f(to)i(asso)5
+ b(ciate)54 b(the)h(con)-5 b(trol)54 b(dep)5 b(endence)55
+ b(to)h(a)f(v)-10 b(ariable)55 b(whic)-5 b(h)55 b(exp)5
+ b(oses)55 b(the)g(relation-)0 9949 y(ships)48 b(b)5 b(et)-5
+ b(w)g(een)48 b(instructions)e(in)i(terms)g(of)g(data)g(\015o)-5
+ b(w.)77 b(Essen)-5 b(tially)-15 b(,)47 b(the)h(con)-5
+ b(trol)48 b(dep)5 b(endence)48 b(is)g(con)-5 b(v)g(erted)47
+ b(to)0 10315 y(a)57 b(data)f(dep)5 b(endence)56 b([3)o(].)78
+ b(One)57 b(of)f(the)h(more)f(p)5 b(opular)56 b(If-con)-5
+ b(v)g(ersion)54 b(algorithms)h(is)h(the)g(RK)h(algorithm)e([32)o(],)0
+ 10680 y(and)61 b(man)-5 b(y)59 b(Mo)5 b(dulo)60 b(Sc)-5
+ b(heduling)59 b(approac)-5 b(hes)60 b([34)o(,)h(13)o(,)g(41)o(])f(use)h
+ (it.)3809 11136 y(18)p eop end
+ %%Page: 19 26
+ TeXDict begin 19 25 bop 282 183 a Fx(If-con)-5 b(v)g(ersion)51
+ b(replaces)h(conditional)f(branc)-5 b(hes)53 b(with)g(a)g(compare)f
+ (instruction)g(that)g(sets)g(a)i(\015ag.)77 b(Instruc-)0
+ 548 y(tions)68 b(that)h(w)-5 b(ere)69 b(dep)5 b(enden)-5
+ b(t)69 b(up)5 b(on)69 b(the)g(conditional)f(branc)-5
+ b(h)69 b(are)g(no)-5 b(w)70 b(instructions)d(that)i(only)g(execute)f
+ (if)0 913 y(the)73 b(\015ag)h(is)f(set.)120 b(If-con)-5
+ b(v)g(ersion)72 b(t)-5 b(ypically)71 b(requires)i(hardw)-5
+ b(are)75 b(supp)5 b(ort,)76 b(but)e(some)f(algorithms)f([41)o(])h(ha)-5
+ b(v)g(e)0 1279 y(made)62 b(sligh)-5 b(t)60 b(mo)5 b(di\014cations)60
+ b(to)i(a)-5 b(v)g(oid)61 b(this.)85 b(Hardw)-5 b(are)63
+ b(supp)5 b(ort)62 b(suc)-5 b(h)62 b(as)f(predicated)h(execution,)e
+ (common)0 1644 y(on)68 b(VLIW)f(and)h(EPIC)f(arc)-5 b(hitectures)66
+ b(\(suc)-5 b(h)67 b(as)h(IA64\))f(set)g(a)h(conditional)e(\015ag)h(p)5
+ b(er)68 b(instruction)e(and)i(allo)-5 b(w)0 2010 y(instructions)58
+ b(to)j(execute)e(only)h(when)h(the)f(conditional)e(\015ag)j(is)f(true.)
+ 282 2375 y(While)i(If-con)-5 b(v)g(ersion)61 b(do)5 b(es)62
+ b(allo)-5 b(w)63 b(lo)5 b(ops)62 b(with)h(conditional)d(statemen)-5
+ b(ts)61 b(to)i(b)5 b(e)63 b(soft)-5 b(w)g(are)62 b(pip)5
+ b(elined,)61 b(the)0 2740 y(do)-5 b(wnside)60 b(is)h(that)f(b)5
+ b(oth)61 b(execution)f(path's)g(resources)g(m)-5 b(ust)60
+ b(b)5 b(e)61 b(summed)f(when)h(determining)e(the)i(resource)0
+ 3106 y(constrain)-5 b(ts)59 b(for)h(the)g(lo)5 b(op.)80
+ b(This)60 b(can)g(lead)g(to)g(a)h(pip)5 b(elined)59 b(lo)5
+ b(op)60 b(that)g(do)5 b(es)60 b(not)g(ha)-5 b(v)g(e)60
+ b(an)h(optimal)d(I)5 b(I.)0 3736 y Fk(3.2.3)225 b(Enhanced)73
+ b(Mo)6 b(dulo)74 b(Sc)-6 b(heduling)0 4219 y Fu(Enhanced)46
+ b(Mo)5 b(dulo)45 b(Sc)-5 b(heduling)45 b Fx([41)o(])h(\(EMS\))f(is)g
+ (another)h(Mo)5 b(dulo)45 b(Sc)-5 b(heduling)45 b(tec)-5
+ b(hnique)45 b(to)h(mo)5 b(dulo)45 b(sc)-5 b(hed-)0 4584
+ y(ule)64 b(lo)5 b(ops)63 b(with)h(conditional)e(branc)-5
+ b(hes)64 b(b)-5 b(y)64 b(translating)e(them)i(in)-5 b(to)63
+ b(straigh)-5 b(t)63 b(line)g(co)5 b(de.)91 b(If-con)-5
+ b(v)g(ersion)62 b(and)0 4950 y(Hierarc)-5 b(hical)87
+ b(Reduction)f(b)5 b(oth)88 b(place)f(restrictions)f(on)i(the)g(sc)-5
+ b(heduling)86 b(of)i(instructions)e(that)h(ma)-5 b(y)87
+ b(pre-)0 5315 y(v)-5 b(en)g(t)65 b(Mo)5 b(dulo)64 b(Sc)-5
+ b(heduling)64 b(from)h(ac)-5 b(hieving)63 b(an)i(optimal)f(I)5
+ b(I.)64 b(EMS)h(attempts)e(to)i(a)-5 b(v)g(oid)65 b(these)f(problems)g
+ (b)-5 b(y)0 5680 y(com)g(bining)56 b(the)h(b)5 b(est)58
+ b(of)f(b)5 b(oth)57 b(algorithms.)78 b(It)57 b(uses)g(If-con)-5
+ b(v)g(ersion,)55 b(without)i(sp)5 b(ecial)57 b(hardw)-5
+ b(are)58 b(supp)5 b(ort,)57 b(to)0 6046 y(eliminate)45
+ b(presc)-5 b(heduling)46 b(conditional)g(constructs.)75
+ b(It)47 b(uses)g(the)h(regeneration)f(tec)-5 b(hniques)46
+ b(lik)-5 b(e)46 b(Hierarc)-5 b(hical)0 6411 y(Reduction)59
+ b(to)h(insert)g(conditional)e(statemen)-5 b(ts)59 b(bac)-5
+ b(k)60 b(after)g(Mo)5 b(dulo)59 b(Sc)-5 b(heduling.)282
+ 6777 y(EMS)49 b(consists)e(of)i(\014v)-5 b(e)48 b(basic)h(steps:)73
+ b(Applying)48 b(If-con)-5 b(v)g(ersion,)49 b(generating)f(the)h(data)f
+ (dep)5 b(endence)48 b(graph,)0 7142 y(Mo)5 b(dulo)85
+ b(Sc)-5 b(heduling)84 b(the)h(lo)5 b(op,)91 b(applying)84
+ b(mo)5 b(dulo)85 b(v)-10 b(ariable)84 b(expansion,)90
+ b(and)c(\014nally)e(regenerating)g(the)0 7507 y(explicit)58
+ b(con)-5 b(trol)60 b(structure)g(of)g(the)g(co)5 b(de)60
+ b(b)-5 b(y)61 b(inserting)e(conditional)f(branc)-5 b(hes.)282
+ 7873 y(If-con)g(v)g(ersion)63 b(is)h(p)5 b(erformed)65
+ b(to)g(transform)e(the)i(lo)5 b(op)65 b(b)5 b(o)g(dy)65
+ b(in)-5 b(to)64 b(straigh)-5 b(t)64 b(line)g(predicated)g(co)5
+ b(de)65 b(using)0 8238 y(the)83 b(RK)h(algorithm)e([32)o(].)149
+ b(By)84 b(using)f(an)g(in)-5 b(ternal)83 b(predicated)f(represen)-5
+ b(tation)82 b(similar)g(to)h(the)g(Cydra)h(5)0 8604 y(pro)5
+ b(cessors)81 b([34],)86 b(conditional)80 b(branc)-5 b(hes)82
+ b(are)g(replaced)f(b)-5 b(y)82 b(a)g(predicate)f(de\014nition)g(and)h
+ (are)g(assigned)e(to)0 8969 y(the)73 b(appropriate)f(basic)g(blo)5
+ b(c)-5 b(ks.)117 b(Eac)-5 b(h)73 b(basic)f(blo)5 b(c)-5
+ b(k)73 b(is)f(assigned)g(one)h(predicate,)i(whic)-5 b(h)72
+ b(has)h(b)5 b(oth)73 b(a)g(true)0 9334 y(and)65 b(a)f(false)g(form.)92
+ b(The)65 b(de\014ne)f(instruction)f(sets)h(the)g(predicate)g(to)g
+ (true/false,)g(and)h(clears)f(the)g(false/true)0 9700
+ y(predicate)59 b(if)h(the)g(instruction)f(is)h(true/false.)282
+ 10065 y(The)i(data)f(dep)5 b(endence)60 b(graph)h(is)g(generated)f(b)-5
+ b(y)61 b(analyzing)f(the)h(an)-5 b(ti,)60 b(true,)h(and)g(output)g(dep)
+ 5 b(endencies)0 10430 y(b)g(et)-5 b(w)g(een)67 b(all)g(instructions)f
+ (just)h(lik)-5 b(e)67 b(previous)g(Mo)5 b(dulo)68 b(Sc)-5
+ b(heduling)66 b(algorithms)g(discussed.)101 b(Sp)5 b(ecial)67
+ b(rules)3809 11136 y(19)p eop end
+ %%Page: 20 27
+ TeXDict begin 20 26 bop 0 183 a Fx(are)59 b(used)g(to)g(determine)f
+ (the)h(dep)5 b(endencies)58 b(when)h(predicates)f(are)h(in)-5
+ b(v)g(olv)g(ed.)79 b(There)59 b(are)h(\015o)-5 b(w)59
+ b(dep)5 b(endences)0 548 y(b)g(et)-5 b(w)g(een)79 b(the)g(instruction)f
+ (that)h(de\014nes)h(the)f(predicate)f(and)i(all)f(instructions)e(that)i
+ (b)5 b(elong)79 b(to)h(the)f(basic)0 913 y(blo)5 b(c)-5
+ b(k)63 b(assigned)f(that)g(predicate.)88 b(Output)63
+ b(dep)5 b(endences)62 b(exist)g(b)5 b(et)-5 b(w)g(een)63
+ b(the)g(predicate)f(de\014ne)h(instruction)0 1279 y(and)68
+ b(the)f(predicate)f(merge)h(instruction.)99 b(The)68
+ b(predicate)f(merge)f(instruction)g(is)h(placed)g(in)g(the)g(blo)5
+ b(c)-5 b(k)67 b(that)0 1644 y(p)5 b(ost)54 b(dominates)f(all)g(of)h
+ (its)g(predecessors.)77 b(Finally)-15 b(,)53 b(there)i(is)e(an)i(an)-5
+ b(ti-dep)5 b(endence)53 b(b)5 b(et)-5 b(w)g(een)54 b(all)f
+ (instructions)0 2010 y(assigned)59 b(a)i(predicate,)e(and)h(the)g
+ (predicate)g(merge.)282 2375 y(EMS)i(uses)g(an)g(iterativ)-5
+ b(e)60 b(Mo)5 b(dulo)62 b(Sc)-5 b(heduling)60 b(algorithm)h(similar)f
+ (to)i(IMS)g([33)o(],)g(but)g(with)g(some)f(minor)0 2740
+ y(enhancemen)-5 b(ts.)92 b(It)65 b(uses)f(the)h(same)f(tec)-5
+ b(hniques)64 b(to)g(select)g(instructions)f(based)i(on)g(priorit)-5
+ b(y)-15 b(,)65 b(and)g(sc)-5 b(hedules)0 3106 y(instructions)66
+ b(at)i(their)g(earliest)f(allo)-5 b(w)g(able)67 b(slot.)103
+ b(Ho)-5 b(w)g(ev)g(er,)70 b(instead)d(of)h(the)g(standard)g(mo)5
+ b(dulo)67 b(reserv)-10 b(ation)0 3471 y(table,)57 b(the)g(table)g(is)g
+ (extended)h(to)f(allo)-5 b(w)57 b(three)h(en)-5 b(tries)56
+ b(p)5 b(er)58 b(slot:)78 b(empt)-5 b(y)-15 b(,)57 b(no-con\015ict,)f
+ (and)i(full.)78 b(No)58 b(con\015ict)0 3836 y(indicates)65
+ b(that)h(there)g(is)g(an)g(instruction)f(sc)-5 b(heduled)65
+ b(for)i(this)e(slot,)i(but)f(other)h(instructions)d(from)i(di\013eren)
+ -5 b(t)0 4202 y(paths)60 b(can)g(b)5 b(e)61 b(sc)-5 b(heduled)59
+ b(in)h(the)g(same)g(slot)f(pro)-5 b(vided)60 b(there)g(is)g(not)g(con)
+ -5 b(trol)60 b(path)g(b)5 b(et)-5 b(w)g(een)60 b(them.)282
+ 4567 y(Mo)5 b(dulo)80 b(V)-15 b(ariable)80 b(Expansion)f(is)h(a)h(tec)
+ -5 b(hnique)79 b(\014rst)h(dev)-5 b(elop)5 b(ed)80 b(b)-5
+ b(y)80 b(Lam)g([25)o(])g(to)h(calculate)d(v)-10 b(ariable)0
+ 4933 y(lifetimes)51 b(of)i(the)h(resulting)f(k)-5 b(ernel.)77
+ b(The)55 b(longest)d(v)-10 b(ariable)53 b(lifetime)e(is)j(used)f(to)h
+ (determine)f(ho)-5 b(w)54 b(man)-5 b(y)54 b(times)0 5298
+ y(to)67 b(unroll)g(the)g(lo)5 b(op)68 b(in)f(order)h(to)f(not)g(o)-5
+ b(v)g(erwrite)67 b(an)-5 b(y)68 b(v)-10 b(alues)66 b(b)5
+ b(efore)68 b(they)f(are)g(used.)102 b(After)67 b(unrolling,)g(the)0
+ 5663 y(v)-10 b(ariables)59 b(are)i(renamed.)282 6029
+ y(Finally)-15 b(,)47 b(EMS)e(m)-5 b(ust)45 b(regenerate)h(the)f(con)-5
+ b(trol)46 b(\015o)-5 b(w)46 b(structure)f(in)h(the)g(newly)f(pip)5
+ b(elined)45 b(lo)5 b(op)45 b(b)-5 b(y)46 b(replacing)0
+ 6394 y(the)60 b(predicate)g(de\014ne)g(instructions)e(with)i
+ (conditional)f(branc)-5 b(hes.)282 6759 y(While)65 b(EMS)h(sounds)g
+ (lik)-5 b(e)65 b(the)g(ideal)h(Global)e(Mo)5 b(dulo)66
+ b(Sc)-5 b(heduling)65 b(algorithm,)g(it)g(w)-5 b(as)67
+ b(only)e(applied)g(to)0 7125 y(lo)5 b(ops)73 b(without)g(lo)5
+ b(op)73 b(carried)h(dep)5 b(endencies)72 b(resulting)g(from)h(memory)g
+ (instructions.)118 b(This)73 b(can)h(seriously)0 7490
+ y(limit)58 b(the)i(n)-5 b(um)g(b)5 b(er)61 b(of)f(v)-10
+ b(alid)59 b(lo)5 b(ops)60 b(to)g(b)5 b(e)60 b(soft)-5
+ b(w)g(are)60 b(pip)5 b(elined.)0 8121 y Fk(3.2.4)225
+ b(Conclusion)0 8604 y Fx(Implemen)-5 b(ting)79 b(all)h(of)h(the)g(Mo)5
+ b(dulo)81 b(Sc)-5 b(heduling)80 b(approac)-5 b(hes)81
+ b(describ)5 b(ed)81 b(in)g(this)f(c)-5 b(hapter)81 b(is)g(outside)f
+ (the)0 8969 y(scop)5 b(e)68 b(of)h(this)f(thesis.)104
+ b(Ho)-5 b(w)g(ev)g(er,)71 b(a)e(study)f(b)-5 b(y)69 b(Co)5
+ b(dina)69 b(et.al)e([10])h(p)5 b(erformed)68 b(an)h(in-depth)f
+ (comparison)g(of)0 9334 y(eac)-5 b(h)64 b(approac)-5
+ b(h.)90 b(They)65 b(found)e(Swing)h(Mo)5 b(dulo)63 b(Sc)-5
+ b(heduling)63 b(to)h(generate)f(the)h(most)f(optimal)f(sc)-5
+ b(hedules)62 b(for)0 9700 y(lo)-5 b(w)71 b(and)g(medium)e(complexit)-5
+ b(y)69 b(arc)-5 b(hitectures.)110 b(Additionally)-15
+ b(,)71 b(for)g(all)f(arc)-5 b(hitectures,)72 b(SMS)f(w)-5
+ b(as)71 b(found)f(to)0 10065 y(b)5 b(e)80 b(the)g(b)5
+ b(est)80 b(at)g(main)-5 b(taining)78 b(lo)-5 b(w)80 b(register)g
+ (pressure)g(and)g(to)5 b(ok)80 b(the)g(least)f(amoun)-5
+ b(t)80 b(of)g(compile)e(time)h(to)0 10430 y(\014nd)57
+ b(an)f(optimal)f(sc)-5 b(hedule.)77 b(F)-15 b(or)57 b(complex)e(arc)-5
+ b(hitectures,)55 b(the)h(iterativ)-5 b(e)55 b(tec)-5
+ b(hniques)55 b(\(IMS)g(and)i(IRIS\))e(b)5 b(oth)3809
+ 11136 y(20)p eop end
+ %%Page: 21 28
+ TeXDict begin 21 27 bop 0 183 a Fx(found)50 b(a)h(more)f(optimal)f(sc)
+ -5 b(hedule,)51 b(but)f(had)h(a)g(m)-5 b(uc)g(h)50 b(higher)g(register)
+ g(pressure.)76 b(Because)50 b(SMS)g(is)g(successful)0
+ 548 y(at)73 b(\014nding)f(an)i(optimal)d(sc)-5 b(hedule)72
+ b(while)g(k)-5 b(eeping)72 b(register)g(pressure)h(lo)-5
+ b(w,)75 b(and)f(do)5 b(es)72 b(b)5 b(oth)73 b(in)g(an)g(e\016cien)-5
+ b(t)0 913 y(manner,)60 b(it)f(app)5 b(ears)61 b(to)f(b)5
+ b(e)60 b(the)g(b)5 b(etter)60 b(approac)-5 b(h.)282 1279
+ y(Both)40 b(Global)f(Mo)5 b(dulo)39 b(Sc)-5 b(heduling)39
+ b(tec)-5 b(hniques,)43 b(Hierarc)-5 b(hal)39 b(Reduction)g(and)i
+ (Enhanced)e(Mo)5 b(dulo)40 b(Sc)-5 b(hedul-)0 1644 y(ing)48
+ b(handle)f(m)-5 b(ultiple)46 b(basic)h(blo)5 b(c)-5 b(ks.)75
+ b(Ho)-5 b(w)g(ev)g(er,)51 b(b)5 b(oth)48 b(tak)-5 b(e)48
+ b(the)f(resource)h(and)g(dep)5 b(endence)48 b(constrain)-5
+ b(ts)46 b(of)i(all)0 2010 y(paths)53 b(within)f(the)h(lo)5
+ b(op)52 b(in)-5 b(to)52 b(consideration)g(when)h(constructing)f(the)g
+ (sc)-5 b(hedule.)77 b(F)-15 b(or)53 b(lo)5 b(ops)52 b(where)h(one)g
+ (path)0 2375 y(is)f(more)h(frequen)-5 b(tly)52 b(executed,)h(this)f
+ (can)h(lead)f(to)h(a)g(less)f(than)h(optimal)e(sc)-5
+ b(hedule.)77 b(The)53 b(extensions)e(to)i(Swing)0 2740
+ y(Mo)5 b(dulo)62 b(Sc)-5 b(heduling)62 b(\(Chapter)i(5\))f(in)-5
+ b(tro)5 b(duce)62 b(a)h(Mo)5 b(dulo)63 b(Sc)-5 b(heduling)62
+ b(tec)-5 b(hnique)62 b(that)h(only)f(considers)g(the)0
+ 3106 y(most)d(frequen)-5 b(tly)60 b(executed)f(\(hot\))h(path)g(of)g
+ (the)g(lo)5 b(op.)3809 11136 y(21)p eop end
+ %%Page: 22 29
+ TeXDict begin 22 28 bop 0 1428 a Fv(Chapter)129 b(4)0
+ 2258 y Fw(Implemen)-13 b(ting)157 b(Swing)e(Mo)13 b(dulo)0
+ 2756 y(Sc)-13 b(heduling)0 3786 y Fu(Swing)47 b(Mo)5
+ b(dulo)46 b(Sc)-5 b(heduling)46 b Fx([27)o(])h(\(SMS\))f(is)h(a)g(Mo)5
+ b(dulo)46 b(Sc)-5 b(heduling)46 b(approac)-5 b(h)47 b(that)f(considers)
+ g(the)h(criticalit)-5 b(y)0 4151 y(of)68 b(instructions)e(and)i(uses)g
+ (heuristics)e(with)i(a)g(lo)-5 b(w)68 b(computational)e(cost.)103
+ b(The)68 b(goal)g(of)g(SMS)g(is)f(to)h(ac)-5 b(hiev)g(e)0
+ 4517 y(the)71 b(theoretical)f(Minim)-5 b(um)69 b(Initiation)g(In)-5
+ b(terv)-10 b(al)71 b(\(MI)5 b(I\),)70 b(as)h(discussed)f(previously)g
+ (in)h(Section)g(3.1,)i(reduce)0 4882 y(the)61 b(n)-5
+ b(um)g(b)5 b(er)62 b(of)f(liv)-5 b(e)61 b(v)-10 b(alues)61
+ b(in)g(the)h(sc)-5 b(hedule)60 b(\(MaxLiv)-5 b(e\))60
+ b(and)i(reduce)g(the)f(Stage)g(Coun)-5 b(t)62 b(\(SC\).)g(The)g(Stage)0
+ 5247 y(Coun)-5 b(t)75 b(is)f(simply)f(the)i(n)-5 b(um)g(b)5
+ b(er)74 b(of)h(iterations)e(liv)-5 b(e)73 b(in)i(the)f(resulting)f(k)-5
+ b(ernel.)123 b(This)75 b(c)-5 b(hapter)74 b(presen)-5
+ b(ts)74 b(our)0 5613 y(implemen)-5 b(tation)57 b(of)j(SMS)g(in)g(the)h
+ (LL)-20 b(VM)59 b(Compiler)h(Infrastructure)f([26)o(].)282
+ 5978 y(Unlik)-5 b(e)54 b(other)h(Mo)5 b(dulo)54 b(Sc)-5
+ b(heduling)53 b(algorithms)g([21)o(,)i(33)o(,)g(12],)g(SMS)f(do)5
+ b(es)55 b(no)f(bac)-5 b(ktrac)g(king)54 b(\(unsc)-5 b(hedul-)0
+ 6344 y(ing)51 b(of)h(instructions\),)e(so)i(instructions)d(are)j(only)f
+ (sc)-5 b(heduled)51 b(once.)77 b(If)51 b(an)g(instruction)f(can)i(not)f
+ (b)5 b(e)52 b(sc)-5 b(heduled,)0 6709 y(the)66 b(whole)g(sc)-5
+ b(hedule)64 b(is)i(cleared,)g(I)5 b(I)66 b(is)f(increased,)h(and)g(sc)
+ -5 b(heduling)65 b(b)5 b(egins)65 b(again.)96 b(SMS)66
+ b(is)g(also)f(unique)g(in)0 7074 y(ho)-5 b(w)58 b(it)f(orders)g
+ (instructions)f(for)h(sc)-5 b(heduling.)78 b(It)57 b(orders)g
+ (instructions)f(b)-5 b(y)57 b(taking)g(the)g(RecMI)5
+ b(I)56 b(of)h(the)g(recur-)0 7440 y(rence)70 b(the)g(instruction)f(b)5
+ b(elongs)69 b(to)h(and)h(the)f(criticalit)-5 b(y)67 b(of)j(the)g(path)g
+ (\(in)g(the)g(Data)g(Dep)5 b(endence)69 b(Graph\))0 7805
+ y(in)-5 b(to)59 b(consideration.)79 b(This)59 b(ordering)h(tec)-5
+ b(hnique)59 b(aims)g(to)h(reduce)f(the)h(stage)g(coun)-5
+ b(t)59 b(and)h(ac)-5 b(hiev)g(e)59 b(a)h(sc)-5 b(hedule)0
+ 8170 y(of)53 b(length)g(MI)5 b(I.)52 b(During)h(sc)-5
+ b(heduling,)53 b(MaxLiv)-5 b(e)52 b(is)g(reduced)i(b)-5
+ b(y)53 b(only)g(sc)-5 b(heduling)52 b(instructions)f(close)i(to)g
+ (their)0 8536 y(predecessors)59 b(and)i(successors.)282
+ 8901 y(Swing)g(Mo)5 b(dulo)59 b(Sc)-5 b(heduling)59 b(is)h(comp)5
+ b(osed)60 b(of)g(three)g(main)f(steps:)222 9416 y(1.)91
+ b(Computation)59 b(and)h(Analysis)f(of)i(the)f(Data)g(Dep)5
+ b(endence)59 b(Graph)i(\(DDG\).)222 9931 y(2.)91 b(No)5
+ b(de)60 b(Ordering.)222 10446 y(3.)91 b(Sc)-5 b(heduling.)3809
+ 11136 y(22)p eop end
+ %%Page: 23 30
+ TeXDict begin 23 29 bop 14 2261 a Fi(f)14 b(o)g(r)29
+ b Fo(\()37 b(i)113 b(=)89 b(0)21 b(;)111 b(i)102 b Fh(<)67
+ b Fo(5)10 b(0)g(0)g(;)69 b(+)10 b(+)33 b(i)38 b(\))244
+ 2418 y(A)11 b([)46 b(i)c(])86 b(=)74 b(A)12 b([)38 b(i)51
+ b Fg(\000)20 b Fo(1)g(])85 b Fg(\003)h Fo(3)20 b(.)g(4)40
+ b(f)j(;)528 2744 y Fx(\(a\))60 b(C)h(Co)5 b(de)2251 210
+ y Fo(\045)g(i)45 b(.)21 b(0)g(.)g(0)89 b(=)96 b Fi(p)7
+ b(h)g(i)103 b(u)10 b(i)g(n)g(t)99 b Fo([)88 b(0)41 b(,)88
+ b(\045)37 b(e)16 b(n)g(t)g(r)g(y)113 b(])48 b(,)96 b([)f(\045)40
+ b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(.)34 b(n)11 b(e)g(x)g(t)37
+ b(,)72 b(\045)32 b(n)20 b(o)p 6719 210 43 7 v 92 w(e)g(x)g(i)g(t)123
+ b(])2251 368 y(\045)-17 b(t)q(m)q(p)19 b(.)f(5)84 b(=)95
+ b Fi(c)12 b(a)g(s)g(t)107 b(u)10 b(i)g(n)g(t)62 b Fo(\045)23
+ b(i)50 b(.)26 b(0)g(.)g(0)107 b Fi(t)8 b(o)102 b(l)8
+ b(o)g(n)g(g)2274 526 y Fo(")20 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g
+ (b)g(a)g(l)39 b(:)20 b(A)n(1)t(")79 b(=)g Fi(g)7 b(e)g(t)g(e)g(l)g(e)g
+ (m)g(e)g(n)g(t)g(p)g(t)g(r)105 b Fo([)24 b(5)f(0)g(0)98
+ b(x)108 b Fi(f)17 b(l)g(o)g(a)g(t)32 b Fo(])13 b Fg(\003)73
+ b Fo(\045)5 b(A)14 b(,)110 b Fi(l)8 b(o)g(n)g(g)92 b
+ Fo(0)2251 683 y(\045)-17 b(t)q(m)q(p)19 b(.)f(6)84 b(=)91
+ b Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)g(r)105
+ b Fo([)23 b(5)g(0)g(0)98 b(x)108 b Fi(f)17 b(l)g(o)g(a)g(t)44
+ b Fo(])25 b Fg(\003)102 b Fo(")20 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g
+ (o)g(b)g(a)g(l)39 b(:)20 b(A)n(1)t(")48 b(,)97 b Fi(l)8
+ b(o)g(n)g(g)102 b Fo(0)44 b(,)101 b Fi(l)8 b(o)g(n)g(g)59
+ b Fo(\045)r(t)q(m)q(p)21 b(.)f(5)2251 841 y(\045)-6 b(c)11
+ b(o)g(p)g(y)g(C)g(o)g(n)g(s)g(t)87 b(=)d Fi(c)12 b(a)g(s)g(t)107
+ b(u)10 b(i)g(n)g(t)91 b Fo(4)17 b(2)g(9)g(4)g(9)g(6)g(7)g(2)g(9)g(5)82
+ b Fi(t)8 b(o)103 b(u)10 b(i)g(n)g(t)2251 999 y Fo(\045)-17
+ b(t)q(m)q(p)19 b(.)f(8)84 b(=)e Fi(a)o(d)o(d)93 b(u)10
+ b(i)g(n)g(t)61 b Fo(\045)24 b(i)42 b(.)19 b(0)g(.)g(0)36
+ b(,)85 b(\045)30 b(c)11 b(o)g(p)g(y)g(C)g(o)g(n)g(s)g(t)2251
+ 1156 y(\045)-17 b(t)q(m)q(p)19 b(.)f(9)84 b(=)95 b Fi(c)12
+ b(a)g(s)g(t)107 b(u)10 b(i)g(n)g(t)62 b Fo(\045)q(t)q(m)q(p)25
+ b(.)g(8)103 b Fi(t)8 b(o)102 b(l)8 b(o)g(n)g(g)2274 1314
+ y Fo(")20 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)20 b(A)n(2)t(")79 b(=)g Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)
+ g(p)g(t)g(r)105 b Fo([)24 b(5)f(0)g(0)98 b(x)108 b Fi(f)17
+ b(l)g(o)g(a)g(t)32 b Fo(])13 b Fg(\003)73 b Fo(\045)5
+ b(A)14 b(,)110 b Fi(l)8 b(o)g(n)g(g)92 b Fo(0)2251 1472
+ y(\045)-17 b(t)q(m)q(p)18 b(.)g(1)g(0)82 b(=)89 b Fi(g)7
+ b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)g(r)105 b
+ Fo([)24 b(5)f(0)g(0)98 b(x)108 b Fi(f)17 b(l)g(o)g(a)g(t)44
+ b Fo(])24 b Fg(\003)103 b Fo(")20 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g
+ (o)g(b)g(a)g(l)38 b(:)21 b(A)n(2)t(")48 b(,)97 b Fi(l)8
+ b(o)g(n)g(g)101 b Fo(0)45 b(,)100 b Fi(l)8 b(o)g(n)g(g)60
+ b Fo(\045)r(t)q(m)q(p)20 b(.)g(9)2251 1630 y(\045)-17
+ b(t)q(m)q(p)18 b(.)g(1)g(1)82 b(=)90 b Fi(l)9 b(o)g(a)g(d)111
+ b(f)17 b(l)g(o)g(a)g(t)24 b Fg(\003)56 b Fo(\045)6 b(t)q(m)q(p)18
+ b(.)g(1)g(0)2251 1787 y(\045)-17 b(t)q(m)q(p)18 b(.)g(1)g(2)82
+ b(=)c Fi(m)l(u)l(l)97 b(f)17 b(l)g(o)g(a)g(t)70 b Fo(\045)r(t)q(m)q(p)
+ 22 b(.)f(1)g(1)43 b(,)90 b(0)32 b(x)11 b(4)g(0)g(0)g(B)g(3)g(3)g(3)g(3)
+ g(4)g(0)g(0)g(0)g(0)g(0)g(0)g(0)2279 1945 y Fi(s)h(t)g(o)g(r)g(e)116
+ b(f)17 b(l)g(o)g(a)g(t)70 b Fo(\045)r(t)q(m)q(p)22 b(.)h(1)f(2)44
+ b(,)110 b Fi(f)17 b(l)g(o)g(a)g(t)25 b Fg(\003)56 b Fo(\045)5
+ b(t)q(m)q(p)20 b(.)g(6)2251 2103 y(\045)o(i)c(n)g(d)g(v)g(a)g(r)40
+ b(.)c(n)14 b(e)g(x)g(t)85 b(=)71 b Fi(a)o(d)o(d)93 b(u)10
+ b(i)g(n)g(t)61 b Fo(\045)24 b(i)47 b(.)24 b(0)g(.)g(0)48
+ b(,)95 b(1)2251 2261 y(\045e)17 b(x)g(i)g(t)g(c)g(o)g(n)g(d)92
+ b(=)82 b Fi(s)10 b(e)g(t)g(e)g(q)105 b(u)10 b(i)g(n)g(t)61
+ b Fo(\045)17 b(i)f(n)g(d)g(v)g(a)g(r)40 b(.)35 b(n)11
+ b(e)g(x)g(t)45 b(,)89 b(5)21 b(0)g(0)2271 2418 y Fi(b)t(r)97
+ b(b)8 b(o)g(o)g(l)60 b Fo(\045)17 b(e)f(x)g(i)g(t)g(c)g(o)g(n)g(d)56
+ b(,)118 b Fi(l)15 b(a)g(b)g(e)g(l)65 b Fo(\045)20 b(l)f(o)g(o)g(p)g(e)g
+ (x)g(i)g(t)63 b(,)117 b Fi(l)15 b(a)g(b)g(e)g(l)65 b
+ Fo(\045)22 b(n)e(o)p 6127 2418 V 91 w(e)g(x)g(i)g(t)4551
+ 2744 y Fx(\(b\))60 b(LL)-20 b(VM)59 b(Co)5 b(de)2555
+ 3362 y(Figure)60 b(4.1:)79 b(Simple)59 b(Lo)5 b(op)61
+ b(Example)282 3899 y(The)48 b(\014rst)f(t)-5 b(w)g(o)47
+ b(are)g(computed)f(once,)j(while)e(sc)-5 b(heduling)46
+ b(is)g(rep)5 b(eated)47 b(un)-5 b(til)46 b(a)h(sc)-5
+ b(hedule)46 b(has)h(b)5 b(een)47 b(ac)-5 b(hiev)g(ed)0
+ 4265 y(or)61 b(the)g(algorithm)e(has)h(reac)-5 b(hed)61
+ b(some)f(maxim)-5 b(um)59 b(I)5 b(I)60 b(and)h(giv)-5
+ b(es)60 b(up.)81 b(Because)60 b(sc)-5 b(heduling)59 b(is)h(the)h(only)f
+ (part)0 4630 y(rep)5 b(eated,)52 b(the)f(computation)e(time)h(is)h(k)-5
+ b(ept)50 b(reasonable.)76 b(Lik)-5 b(e)51 b(other)f(Mo)5
+ b(dulo)51 b(Sc)-5 b(heduling)50 b(algorithms,)g(SMS)0
+ 4995 y(w)-5 b(orks)52 b(on)g(all)e(innermost)h(lo)5 b(ops)51
+ b(without)g(calls)f(and)i(con)-5 b(trol)51 b(\015o)-5
+ b(w.)77 b(Lo)5 b(op)52 b(reconstruction)e(is)h(p)5 b(erformed)51
+ b(after)0 5361 y(sc)-5 b(heduling)59 b(is)h(successful,)d(but)k(is)f
+ (not)g(tec)-5 b(hnically)58 b(part)i(of)g(the)h(SMS)f(algorithm.)282
+ 5726 y(Swing)54 b(Mo)5 b(dulo)53 b(Sc)-5 b(heduling)52
+ b(w)-5 b(as)54 b(originally)e(c)-5 b(hosen)53 b(o)-5
+ b(v)g(er)54 b(other)g(Mo)5 b(dulo)53 b(Sc)-5 b(heduling)52
+ b(algorithms)g(men-)0 6092 y(tioned)82 b(in)g(Chapter)g(3)h(b)5
+ b(ecause)81 b(of)h(its)g(abilit)-5 b(y)81 b(to)h(k)-5
+ b(eep)82 b(computation)e(time)i(to)g(a)g(minim)-5 b(um,)85
+ b(while)d(still)0 6457 y(ac)-5 b(hieving)61 b(MI)5 b(I)62
+ b(and)h(k)-5 b(eeping)62 b(register)g(pressure)g(lo)-5
+ b(w.)87 b(W)-15 b(e)63 b(discuss)e(our)i(exp)5 b(eriences)62
+ b(with)g(ho)-5 b(w)63 b(SMS)g(actu-)0 6822 y(ally)c(p)5
+ b(erformed)60 b(in)g(Chapter)h(6.)0 7577 y Ft(4.1)270
+ b(LL)-30 b(VM)89 b(Compiler)h(Infrastructure)0 8122 y
+ Fx(Swing)66 b(Mo)5 b(dulo)65 b(Sc)-5 b(heduling)65 b(w)-5
+ b(as)66 b(implemen)-5 b(ted)63 b(in)i(the)h(Lo)-5 b(w)66
+ b(Lev)-5 b(el)65 b(Virtual)g(Mac)-5 b(hine)65 b(\(LL)-20
+ b(VM\))64 b(Compiler)0 8488 y(Infrastructure)39 b([26].)73
+ b(LL)-20 b(VM)40 b(is)g(a)h(lo)-5 b(w-lev)g(el,)42 b(RISC-lik)-5
+ b(e)39 b(instruction)g(set)h(and)h(ob)10 b(ject)40 b(co)5
+ b(de)41 b(represen)-5 b(tation.)72 b(It)0 8853 y(pro)-5
+ b(vides)63 b(t)-5 b(yp)5 b(e)64 b(information)e(and)i(data)g(\015o)-5
+ b(w)64 b(information)e(\(using)h(SSA)i([11)o(]\),)f(while)f(still)f(b)5
+ b(eing)64 b(extremely)0 9218 y(ligh)-5 b(t-w)g(eigh)g(t.)127
+ b(The)77 b(LL)-20 b(VM)76 b(Compiler)g(Infrastructure)g(pro)-5
+ b(vides)76 b(optimizations)e(that)i(can)h(b)5 b(e)77
+ b(applied)e(at)0 9584 y(compile)59 b(time,)f(link-time,)g(run-time,)g
+ (and)j(o\017ine)e(pro\014le)h(driv)-5 b(en)60 b(transformations.)282
+ 9949 y(SMS)g(w)-5 b(as)60 b(implemen)-5 b(ted)57 b(as)j(a)g(static)e
+ (optimization)f(in)j(the)f(SP)-15 b(AR)-5 b(C)60 b(V9)h(bac)-5
+ b(k-end.)79 b(SMS)60 b(is)f(p)5 b(erformed)0 10315 y(b)g(efore)86
+ b(register)f(allo)5 b(cation,)91 b(but)86 b(after)g(lo)5
+ b(cal)85 b(sc)-5 b(heduling.)156 b(Ho)-5 b(w)g(ev)g(er,)93
+ b(nothing)86 b(in)g(our)h(implemen)-5 b(tation)0 10680
+ y(prev)g(en)g(ts)77 b(it)g(from)h(b)5 b(eing)77 b(p)5
+ b(erformed)77 b(at)h(run-time)e(or)i(o\017ine.)132 b(The)78
+ b(SP)-15 b(AR)-5 b(C)78 b(bac)-5 b(k-end)77 b(uses)g(a)h(lo)-5
+ b(w-lev)g(el)3809 11136 y(23)p eop end
+ %%Page: 24 31
+ TeXDict begin 24 30 bop 15 210 a Fo(\()21 b(n)7 b(1)30
+ b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)66 b Fo(\045)5 b(l)t(m)14
+ b(\()20 b Fg(\000)10 b Fo(1)g(\))20 b(,)66 b(\045)26
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12
+ b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g(0)23 b(\))15 368 y(\()e(n)7
+ b(2)30 b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)66 b Fo(\045)5
+ b(h)t(h)g(\()o(\045)15 b(d)i(i)g(s)g(p)35 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)t Fo(v)i(a)g(l)93
+ b(A)5 b(\))16 b(\))31 b(,)78 b(\045)32 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(a)g(9)g
+ (0)22 b(\))15 526 y(\()f(n)7 b(3)30 b(\))90 b Fi(a)o(d)o(d)49
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(b)g(b)g(0)g(2)g(0)g(0)117 b(i)51
+ b(.)27 b(0)g(.)h(0)f(:)33 b(P)5 b(h)g(i)g(C)g(p)18 b(\))27
+ b(,)74 b(\045)20 b(g)7 b(0)26 b(,)72 b(\045)29 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g
+ (f)g(6)g(a)g(0)122 b(i)47 b(.)25 b(0)g(.)g(0)f(\))15
+ 683 y(\()d(n)7 b(4)30 b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)66
+ b Fo(\045)5 b(h)t(h)i(\()r Fh(<)j Fo(c)f(p)14 b(#)t(1)7
+ b Fh(>)t Fo(\))g(,)53 b(\045)20 b(r)c(e)g(g)31 b(\()h(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)22
+ b(\))15 841 y(\()f(n)7 b(5)30 b(\))98 b Fi(o)7 b(r)58
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(a)g(9)g(0)20 b(\))27
+ b(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g(0)24 b(\))15 999 y(\()d(n)7
+ b(6)30 b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)66 b Fo(\045)5
+ b(l)t(m)t(\()o(\045)15 b(d)i(i)g(s)g(p)35 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)t Fo(v)i(a)g(l)93
+ b(A)5 b(\))16 b(\))31 b(,)78 b(\045)32 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(c)g(7)g
+ (0)30 b(\))15 1156 y(\()21 b(n)7 b(7)30 b(\))98 b Fi(o)7
+ b(r)58 b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)20
+ b(\))27 b(,)74 b(\045)t(h)-9 b(m)h(\()r Fh(<)11 b Fo(c)e(p)14
+ b(#)t(1)7 b Fh(>)t Fo(\))g(,)53 b(\045)19 b(r)d(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g
+ (0)22 b(\))15 1314 y(\()f(n)7 b(8)30 b(\))98 b Fi(o)7
+ b(r)58 b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g(0)21
+ b(\))27 b(,)74 b(\045)33 b(l)20 b(o)29 b(\()20 b Fg(\000)10
+ b Fo(1)g(\))20 b(,)66 b(\045)25 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g(0)29
+ b(\))15 1472 y(\()21 b(n)7 b(9)30 b(\))90 b Fi(a)o(d)o(d)49
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31
+ b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122 b(i)43
+ b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g
+ (0)28 b(\))f(,)73 b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)22 b(\))15 1630 y(\()h(n)9
+ b(1)g(0)30 b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(l)t(m)g(\()r Fh(<)11 b Fo(c)e(p)14 b(#)t(1)7 b Fh(>)t
+ Fo(\))g(,)53 b(\045)19 b(r)d(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g(0)22
+ b(\))15 1787 y(\()h(n)9 b(1)g(1)30 b(\))112 b Fi(s)20
+ b(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)27 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g(0)28
+ b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(b)g(d)g(0)28 b(\))15 1945 y(\()23 b(n)9 b(1)g(2)30
+ b(\))112 b Fi(s)20 b(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g
+ (0)25 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g
+ (5)g(7)g(e)g(0)30 b(\))15 2103 y(\()23 b(n)9 b(1)g(3)30
+ b(\))99 b Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g(0)20
+ b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(e)g(0)28
+ b(\))e(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g(0)22
+ b(\))15 2261 y(\()h(n)9 b(1)g(4)30 b(\))106 b Fi(s)14
+ b(e)g(t)g(h)g(i)67 b Fo(\045)5 b(h)t(h)t(\()o(\045)16
+ b(d)h(i)g(s)g(p)34 b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q
+ Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16
+ b(\))30 b(,)79 b(\045)32 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g(2)g(f)g(6)g(0)29
+ b(\))15 2418 y(\()23 b(n)9 b(1)g(5)30 b(\))99 b Fi(o)7
+ b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(c)g(7)g(0)28
+ b(\))f(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(d)g(0)26
+ b(\))g(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g(0)24
+ b(\))15 2576 y(\()f(n)9 b(1)g(6)30 b(\))111 b Fi(s)19
+ b(r)g(l)71 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83
+ b(\045)34 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)96 b(t)q(m)q(p)22
+ b(.)h(8)f(\))15 2734 y(\()h(n)9 b(1)g(7)30 b(\))99 b
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g(0)23
+ b(\))k(,)74 b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g(0)30 b(\))15 2892 y(\()23
+ b(n)9 b(1)g(8)30 b(\))117 b Fi(s)25 b(l)g(l)75 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)95 b(t)q(m)q(p)20
+ b(.)g(8)g(\))39 b(,)86 b(2)39 b(,)87 b(\045)36 b(r)16
+ b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(9)g(5)g(0)22 b(\))15 3049 y(\()h(n)9 b(1)g(9)30
+ b(\))99 b Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g(0)20
+ b(\))27 b(,)74 b(\045)32 b(l)20 b(o)h(\()r Fh(<)11 b
+ Fo(c)e(p)k(#)t(1)7 b Fh(>)t Fo(\))g(,)53 b(\045)20 b(r)c(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g
+ (0)27 b(\))15 3207 y(\()c(n)9 b(2)g(0)30 b(\))99 b Fi(o)7
+ b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g(2)g(f)g(6)g(0)28
+ b(\))f(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g(0)22 b(\))15 3365 y(\()h(n)9
+ b(2)g(1)30 b(\))91 b Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g
+ (0)32 b(\))k(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g
+ (0)107 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)21 b(A)n(2)11 b(\))15 3523 y(\()23 b(n)9 b(2)g(2)30
+ b(\))103 b Fi(l)11 b(d)63 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g
+ (0)31 b(\))k(,)83 b(0)35 b(,)82 b(\045)34 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(1)g(7)g(f)g(c)g
+ (0)28 b(\))15 3680 y(\()23 b(n)9 b(2)g(3)30 b(\))112
+ b Fi(s)20 b(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g
+ (0)25 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g
+ (0)g(6)g(4)g(0)22 b(\))15 3838 y(\()h(n)9 b(2)g(4)30
+ b(\))106 b Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5 b(l)t(m)s(\()o(\045)
+ 16 b(d)h(i)g(s)g(p)34 b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q
+ Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16
+ b(\))30 b(,)79 b(\045)32 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g(0)29
+ b(\))15 3996 y(\()23 b(n)9 b(2)g(5)30 b(\))103 b Fi(l)11
+ b(d)63 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g(0)108
+ b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)38
+ b(:)21 b(A)n(2)10 b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(5)g
+ (0)21 b(\))26 b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)29 b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)97
+ b(t)q(m)q(p)21 b(.)g(1)g(1)g(\))15 4154 y(\()i(n)9 b(2)g(6)30
+ b(\))117 b Fi(s)25 b(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g
+ (0)122 b(i)44 b(.)21 b(0)g(.)g(0)g(\))43 b(,)89 b(2)42
+ b(,)90 b(\045)37 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g(0)24
+ b(\))15 4311 y(\()f(n)9 b(2)g(7)30 b(\))99 b Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g(0)28 b(\))f(,)74
+ b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(4)g(0)20 b(\))26
+ b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)22
+ b(\))15 4469 y(\()h(n)9 b(2)g(8)30 b(\))91 b Fi(a)o(d)o(d)48
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)31
+ b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122 b(i)44
+ b(.)21 b(0)g(.)g(0)g(\))43 b(,)89 b(1)42 b(,)90 b(\045)37
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104 b(m)6 b(a)g(s)g(k)g(H)g(i)22
+ b(\))15 4627 y(\()h(n)9 b(2)g(9)30 b(\))99 b Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)20 b(\))27
+ b(,)74 b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)25 b(\))15 4785 y(\()e(n)9
+ b(3)g(0)30 b(\))111 b Fi(s)19 b(r)g(l)71 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104 b(m)6 b(a)g(s)g(k)g(H)g(i)25
+ b(\))35 b(,)83 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g
+ (0)109 b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(.)c(n)14 b(e)g(x)g(t)28
+ b(\))15 4942 y(\()23 b(n)9 b(3)g(1)30 b(\))91 b Fi(a)o(d)o(d)48
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)109 b(i)16
+ b(n)g(d)g(v)g(a)g(r)40 b(.)d(n)14 b(e)g(x)g(t)26 b(\))h(,)74
+ b(\045)20 b(g)7 b(0)25 b(,)73 b(\045)28 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(0)g(2)g(0)g
+ (0)117 b(i)51 b(.)27 b(0)g(.)h(0)f(:)33 b(P)5 b(h)g(i)g(C)g(p)20
+ b(\))15 5100 y(\()j(n)9 b(3)g(2)30 b(\))91 b Fi(a)o(d)o(d)48
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)27 b(\))36
+ b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)107
+ b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)21 b(A)n(1)11 b(\))15 5258 y(\()23 b(n)9 b(3)g(3)30
+ b(\))98 b Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g
+ (0)109 b(i)16 b(n)g(d)g(v)g(a)g(r)39 b(.)e(n)14 b(e)g(x)g(t)30
+ b(\))k(,)82 b(5)17 b(0)g(0)33 b(,)82 b(\045)23 b(g)7
+ b(0)26 b(,)73 b(\045)30 b(c)18 b(c)g(r)g(e)g(g)33 b(\()f(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g(0)30
+ b(\))15 5416 y(\()23 b(n)9 b(3)g(4)30 b(\))107 b(f)15
+ b(m)g(u)g(l)g(s)65 b(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)96
+ b(t)q(m)q(p)18 b(.)f(1)g(1)g(\))33 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(1)g
+ (7)g(f)g(c)g(0)26 b(\))g(,)74 b(\045)30 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g
+ (0)94 b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))15 5573 y(\()i(n)9
+ b(3)g(5)30 b(\))106 b Fi(s)14 b(t)65 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g
+ (0)93 b(t)q(m)q(p)18 b(.)f(1)g(2)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)107 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)
+ g(l)g(o)g(b)g(a)g(l)39 b(:)21 b(A)n(1)10 b(\))26 b(,)74
+ b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g(0)25 b(\))15
+ 5731 y(\()e(n)9 b(3)g(6)30 b(\))94 b Fi(b)q(e)52 b Fo(\045)19
+ b(c)f(c)g(r)g(e)g(g)33 b(\()f(v)17 b(a)g(l)101 b(0)31
+ b(x)14 b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g(0)28 b(\))e(,)74
+ b(\045)30 b(d)17 b(i)g(s)g(p)35 b(\()i(l)22 b(a)g(b)g(e)g(l)128
+ b(l)21 b(o)g(o)g(p)g(e)g(x)g(i)g(t)35 b(\))15 5889 y(\()23
+ b(n)9 b(3)g(7)30 b(\))92 b Fi(ba)51 b Fo(\045)18 b(d)f(i)g(s)g(p)34
+ b(\()j(l)23 b(a)f(b)g(e)g(l)128 b(n)20 b(o)p 1996 5889
+ 43 7 v 91 w(e)g(x)g(i)g(t)36 b(\))1834 6380 y Fx(Figure)60
+ b(4.2:)79 b(LL)-20 b(VM)60 b(Mac)-5 b(hine)59 b(Co)5
+ b(de)61 b(for)f(a)h(Simple)e(Lo)5 b(op)0 6884 y(represen)-5
+ b(tation)69 b(that)i(closely)e(mo)5 b(dels)70 b(the)g(SP)-15
+ b(AR)-5 b(C)72 b(V9)f(assem)-5 b(bly)69 b([1].)111 b(Eac)-5
+ b(h)70 b(instruction)g(has)g(an)h(op)5 b(co)g(de)0 7249
+ y(and)85 b(a)g(list)f(of)h(op)5 b(erands.)154 b(F)-15
+ b(or)85 b(SMS)g(in)f(the)h(SP)-15 b(AR)-5 b(C)86 b(bac)-5
+ b(k-end,)90 b(w)-5 b(e)85 b(only)g(deal)f(with)h(op)5
+ b(erands)85 b(of)f(the)0 7615 y(follo)-5 b(wing)59 b(t)-5
+ b(yp)5 b(es:)273 8109 y Fr(\017)91 b Fj(Mac)-6 b(hine)72
+ b(Register)p Fx(:)84 b(This)62 b(is)g(a)g(represen)-5
+ b(tation)61 b(of)h(a)g(ph)-5 b(ysical)61 b(register)g(for)h(the)g(SP)
+ -15 b(AR)-5 b(C)63 b(arc)-5 b(hitec-)455 8475 y(ture.)273
+ 8966 y Fr(\017)91 b Fj(Virtual)78 b(Register)p Fx(:)96
+ b(These)68 b(are)g(LL)-20 b(VM)67 b(v)-10 b(alues,)69
+ b(whic)-5 b(h)68 b(is)f(the)h(base)g(represen)-5 b(tation)66
+ b(for)i(all)f(v)-10 b(alues)455 9332 y(computed)59 b(b)-5
+ b(y)60 b(the)h(program)f(that)g(ma)-5 b(y)60 b(b)5 b(e)60
+ b(used)g(as)h(op)5 b(erands)60 b(to)g(other)g(v)-10 b(alues.)273
+ 9823 y Fr(\017)91 b Fj(Condition)69 b(Co)6 b(de)69 b(Register)p
+ Fx(:)81 b(The)60 b(register)g(that)g(stores)g(the)g(results)f(of)h(a)h
+ (compare)e(op)5 b(eration.)273 10315 y Fr(\017)91 b Fj(PC)73
+ b(Relativ)-6 b(e)73 b(Displacemen)-6 b(t)p Fx(:)88 b(A)65
+ b(displacemen)-5 b(t)61 b(that)i(is)g(added)h(to)f(the)g(program)h
+ (coun)-5 b(ter)63 b(\(PC\).)455 10680 y(This)d(is)g(used)g(for)g(sp)5
+ b(ecifying)58 b(co)5 b(de)61 b(addresses)e(in)h(con)-5
+ b(trol)60 b(transfer)g(instructions)e(\(i.e.)79 b(branc)-5
+ b(hes\).)3809 11136 y(24)p eop end
+ %%Page: 25 32
+ TeXDict begin 25 31 bop 273 183 a Fr(\017)91 b Fj(Global)69
+ b(Address)p Fx(:)82 b(The)60 b(address)g(for)h(a)f(global)g(v)-10
+ b(ariable.)282 747 y(Throughout)78 b(this)g(Chapter,)k(w)-5
+ b(e)78 b(illustrate)e(the)i(phases)f(of)h(Swing)g(Mo)5
+ b(dulo)77 b(Sc)-5 b(heduling)77 b(on)h(a)g(simple)0 1113
+ y(example.)g(Figure)57 b(4.1)f(sho)-5 b(ws)58 b(a)f(C)h(for-lo)5
+ b(op)56 b(that)h(sets)g(elemen)-5 b(ts)55 b(of)i(a)h(\015oating)e(p)5
+ b(oin)-5 b(t)57 b(arra)-5 b(y)58 b(to)f(the)g(previous)0
+ 1478 y(elemen)-5 b(t)69 b(m)-5 b(ultiplied)67 b(b)-5
+ b(y)71 b(some)f(constan)-5 b(t.)109 b(It)70 b(also)f(sho)-5
+ b(ws)70 b(the)h(LL)-20 b(VM)69 b(represen)-5 b(tation)69
+ b(for)i(the)f(lo)5 b(op.)109 b(This)0 1843 y(lo)5 b(op)72
+ b(is)f(p)5 b(erfect)72 b(for)g(SMS)g(since)f(\015oating)h(p)5
+ b(oin)-5 b(t)71 b(computations)f(t)-5 b(ypically)71 b(ha)-5
+ b(v)g(e)72 b(a)g(high)g(latency)f(and)h(it)g(is)0 2209
+ y(ideal)46 b(to)h(o)-5 b(v)g(erlap)46 b(their)g(execution)g(with)g
+ (other)h(instructions.)74 b(Figure)46 b(4.2)g(sho)-5
+ b(ws)47 b(the)g(LL)-20 b(VM)46 b(co)5 b(de)47 b(translated)0
+ 2574 y(to)70 b(a)h(mac)-5 b(hine)69 b(co)5 b(de)70 b(represen)-5
+ b(tation)69 b(that)h(closely)f(mo)5 b(dels)69 b(the)i(SP)-15
+ b(AR)-5 b(C)70 b(V9)h(instruction)e(set)h([1)o(].)110
+ b(SMS)71 b(is)0 2940 y(p)5 b(erformed)54 b(on)g(this)f(lo)-5
+ b(w-lev)g(el)53 b(represen)-5 b(tation.)76 b(Lastly)-15
+ b(,)54 b(Figure)f(4.3)h(sho)-5 b(ws)54 b(the)g(LL)-20
+ b(VM)53 b(instructions)g(for)h(our)0 3305 y(simple)59
+ b(lo)5 b(op)60 b(example)f(and)h(their)g(corresp)5 b(onding)60
+ b(mac)-5 b(hine)59 b(instructions.)0 3935 y Fk(4.1.1)225
+ b(Arc)-6 b(hitecture)73 b(Resource)i(Description)0 4418
+ y Fx(The)62 b(LL)-20 b(VM)60 b(Compiler)h(Infrastructure)f(pro)-5
+ b(vides)60 b(a)i Fu(Sc)-5 b(hedInfo)60 b(API)h Fx(to)g(access)g
+ (information)e(ab)5 b(out)61 b(the)g(ar-)0 4784 y(c)-5
+ b(hitecture)43 b(resources)h(that)g(are)g(crucial)f(for)i(Sc)-5
+ b(heduling)43 b(of)h(an)-5 b(y)44 b(kind,)j(including)c(Swing)h(Mo)5
+ b(dulo)44 b(Sc)-5 b(heduling.)0 5149 y(The)61 b(Sc)-5
+ b(hedInfo)59 b(API)h(pro)-5 b(vides)60 b(information)e(suc)-5
+ b(h)61 b(as)f(the)g(follo)-5 b(wing:)273 5664 y Fr(\017)91
+ b Fx(Instruction)f(Resource)h(Usage:)144 b(The)92 b(resources)g(an)g
+ (instruction)e(uses)i(during)g(eac)-5 b(h)91 b(stage)h(of)f(the)455
+ 6029 y(pip)5 b(eline.)273 6544 y Fr(\017)91 b Fx(Resources)59
+ b(Av)-10 b(ailable:)79 b(The)60 b(resources)g(and)h(n)-5
+ b(um)g(b)5 b(er)60 b(of)g(eac)-5 b(h)60 b(resource.)273
+ 7059 y Fr(\017)91 b Fx(Issue)59 b(Slots:)79 b(T)-15 b(otal)60
+ b(n)-5 b(um)g(b)5 b(er)60 b(of)g(issue)g(slots.)273 7574
+ y Fr(\017)91 b Fx(T)-15 b(otal)73 b(Latency:)105 b(The)74
+ b(asso)5 b(ciated)72 b(latency)h(for)g(eac)-5 b(h)74
+ b(instruction)e(\(or)h(class)g(of)g(instructions\))e(whic)-5
+ b(h)455 7939 y(is)79 b(the)i(time)e(\(in)h(cycles\))f(for)h(ho)-5
+ b(w)81 b(long)f(it)g(tak)-5 b(es)80 b(from)g(the)g(time)f(the)h
+ (instruction)f(starts)h(un)-5 b(til)79 b(its)455 8304
+ y(dep)5 b(enden)-5 b(ts)59 b(can)h(use)h(its)e(results.)282
+ 8819 y(F)-15 b(or)46 b(our)g(implemen)-5 b(tation)42
+ b(w)-5 b(e)46 b(ha)-5 b(v)g(e)46 b(written)f(a)g(Sc)-5
+ b(hedInfo)45 b(description)f(for)i(the)f(SP)-15 b(AR)-5
+ b(C)46 b(I)5 b(I)g(Ii)45 b(arc)-5 b(hitecture)0 9185
+ y(whic)g(h)60 b(is)g(describ)5 b(ed)60 b(in)g(Section)f(6.1.)3809
+ 11136 y(25)p eop end
+ %%Page: 26 33
+ TeXDict begin 26 32 bop 162 387 a Ff(\045i.0.0)61 b(=)d(phi)i(uin)-5
+ b(t)59 b([)g(0,)h(\045en)-5 b(try)59 b(],)h([)f(\045indv)-10
+ b(ar.next,)61 b(\045no)p 4226 387 54 7 v 64 w(exit)f(])324
+ 570 y Fs(\(n31\))51 b(add)g(\045reg\(v)-9 b(al)52 b(0x100bb9e40)e(indv)
+ -9 b(ar.next\),)52 b(\045g0,)e(\045reg\(v)-9 b(al)51
+ b(0x100bb0200)g(i.0.0:PhiCp\))324 753 y(\(n3\))g(add)h(\045reg\(v)-9
+ b(al)51 b(0x100bb0200)f(i.0.0:PhiCp\),)f(\045g0,)h(\045reg\(v)-9
+ b(al)51 b(0x100baf6a0)f(i.0.0\))162 935 y Ff(\045tmp.5)60
+ b(=)f(cast)f(uin)-5 b(t)59 b(\045i.0.0)i(to)e(long)162
+ 1118 y("addrOfGlobal:A1")j(=)c(getelemen)-5 b(tptr)60
+ b([500)h(x)e(\015oat]*)h(\045A,)g(long)g(0)324 1301 y
+ Fs(\(n14\))51 b(sethi)g(\045hh\(\045disp\(addr-of-v)-9
+ b(al)51 b(A\)\),)g(\045reg\(v)-9 b(al)51 b(0x100d12f60\))324
+ 1483 y(\(n20\))g(or)g(\045reg\(v)-9 b(al)51 b(0x100d12f60\),)e
+ (\045hm\(\045disp\(addr-of-v)-9 b(al)52 b(A\)\),)e(\045reg\(v)-9
+ b(al)51 b(0x100d13000\))324 1666 y(\(n23\))g(sllx)f(\045reg\(v)-9
+ b(al)51 b(0x100d13000\),)e(32,)i(\045reg\(v)-9 b(al)51
+ b(0x100d10640\))324 1849 y(\(n24\))g(sethi)g
+ (\045lm\(\045disp\(addr-of-v)-9 b(al)50 b(A\)\),)h(\045reg\(v)-9
+ b(al)51 b(0x100d106e0\))324 2031 y(\(n27\))g(or)g(\045reg\(v)-9
+ b(al)51 b(0x100d106e0\),)f(\045reg\(v)-9 b(al)51 b(0x100d10640\),)e
+ (\045reg\(v)-9 b(al)51 b(0x100d10780\))324 2214 y(\(n29\))g(or)g
+ (\045reg\(v)-9 b(al)51 b(0x100d10780\),)e(\045lo\(\045disp\(addr-of-v)
+ -9 b(al)51 b(A\)\),)f(\045reg\(v)-9 b(al)51 b(0x100d33d30\))324
+ 2397 y(\(n32\))g(add)g(\045reg\(v)-9 b(al)52 b(0x100d33d30\),)d(0,)i
+ (\045reg\(v)-9 b(al)51 b(0x100bb7460)f(addrOfGlobal:A1\))162
+ 2579 y Ff(\045tmp.6)60 b(=)f(getelemen)-5 b(tptr)60 b([500)g(x)g
+ (\015oat]*)g("addrOfGlobal:A1",)h(long)f(0,)g(long)g(\045tmp.5)324
+ 2762 y Fs(\(n26\))51 b(sll)f(\045reg\(v)-9 b(al)51 b(0x100baf6a0)f
+ (i.0.0\),)f(2,)i(\045reg\(v)-9 b(al)51 b(0x100d318b0\))162
+ 2945 y Ff(\045cop)-5 b(yConst)60 b(=)e(cast)g(uin)-5
+ b(t)60 b(4294967295)j(to)c(uin)-5 b(t)324 3127 y Fs(\(n1\))51
+ b(sethi)g(\045lm\(-1\),)f(\045reg\(v)-9 b(al)51 b(0x100d0eb20\))324
+ 3310 y(\(n8\))g(or)g(\045reg\(v)-9 b(al)51 b(0x100d0eb20\),)f
+ (\045lo\(-1\),)g(\045reg\(v)-9 b(al)51 b(0x100d0ea80\))162
+ 3493 y Ff(\045tmp.8)60 b(=)f(add)g(uin)-5 b(t)60 b(\045i.0.0,)g
+ (\045cop)-5 b(yConst)324 3675 y Fs(\(n9\))51 b(add)h(\045reg\(v)-9
+ b(al)51 b(0x100baf6a0)f(i.0.0\),)f(\045reg\(v)-9 b(al)51
+ b(0x100d0ea80\),)f(\045reg\(v)-9 b(al)51 b(0x100d0e9e0)f(maskHi\))324
+ 3858 y(\(n16\))h(srl)f(\045reg\(v)-9 b(al)51 b(0x100d0e9e0)g(maskHi\),)
+ f(0,)h(\045reg\(v)-9 b(al)51 b(0x100bb9a50)f(tmp.8\))162
+ 4040 y Ff(\045tmp.9)60 b(=)f(cast)f(uin)-5 b(t)59 b(\045tmp.8)h(to)g
+ (long)162 4223 y("addrOfGlobal:A2")i(=)c(getelemen)-5
+ b(tptr)60 b([500)h(x)e(\015oat]*)h(\045A,)g(long)g(0)324
+ 4406 y Fs(\(n2\))51 b(sethi)g(\045hh\(\045disp\(addr-of-v)-9
+ b(al)52 b(A\)\),)e(\045reg\(v)-9 b(al)51 b(0x100d31a90\))324
+ 4588 y(\(n5\))g(or)g(\045reg\(v)-9 b(al)51 b(0x100d31a90\),)e
+ (\045hm\(\045disp\(addr-of-v)-9 b(al)52 b(A\)\),)e(\045reg\(v)-9
+ b(al)51 b(0x100d31b30\))324 4771 y(\(n11\))g(sllx)f(\045reg\(v)-9
+ b(al)51 b(0x100d31b30\),)f(32,)g(\045reg\(v)-9 b(al)51
+ b(0x100d31b)t(d0\))324 4954 y(\(n6\))g(sethi)g
+ (\045lm\(\045disp\(addr-of-v)-9 b(al)51 b(A\)\),)f(\045reg\(v)-9
+ b(al)51 b(0x100d31c70\))324 5136 y(\(n15\))g(or)g(\045reg\(v)-9
+ b(al)51 b(0x100d31c70\),)f(\045reg\(v)-9 b(al)51 b(0x100d31b)t(d0\),)f
+ (\045reg\(v)-9 b(al)51 b(0x100d31d10\))324 5319 y(\(n17\))g(or)g
+ (\045reg\(v)-9 b(al)51 b(0x100d31d10\),)f(\045lo\(\045disp\(addr-of-v)
+ -9 b(al)50 b(A\)\),)h(\045reg\(v)-9 b(al)51 b(0x100d319f0\))324
+ 5502 y(\(n21\))g(add)g(\045reg\(v)-9 b(al)52 b(0x100d319f0\),)d(0,)h
+ (\045reg\(v)-9 b(al)52 b(0x100bb73a0)e(addrOfGlobal:A2\))162
+ 5684 y Ff(\045tmp.10)61 b(=)d(getelemen)-5 b(tptr)60
+ b([500)h(x)e(\015oat]*)h("addrOfGlobal:A2",)i(long)e(0,)f(long)h
+ (\045tmp.9)324 5867 y Fs(\(n18\))51 b(sll)f(\045reg\(v)-9
+ b(al)51 b(0x100bb9a50)f(tmp.8\),)g(2,)h(\045reg\(v)-9
+ b(al)51 b(0x100d31950\))162 6050 y Ff(\045tmp.11)61 b(=)d(load)i
+ (\015oat*)g(\045tmp.10)324 6232 y Fs(\(n25\))51 b(ld)g(\045reg\(v)-9
+ b(al)51 b(0x100bb73a0)f(addrOfGlobal:A2\),)g(\045reg\(v)-9
+ b(al)51 b(0x100d31950\),)e(\045reg\(v)-9 b(al)52 b(0x100bb9bf0)f
+ (tmp.11\))162 6415 y Ff(\045tmp.12)61 b(=)d(m)-5 b(ul)60
+ b(\015oat)f(\045tmp.11,)i(0x400B333340000000)324 6598
+ y Fs(\(n4\))51 b(sethi)g(\045hh\(\),)f(\045reg\(v)-9
+ b(al)51 b(0x100d18060\))324 6780 y(\(n7\))g(or)g(\045reg\(v)-9
+ b(al)51 b(0x100d18060\),)e(\045hm\(\),)i(\045reg\(v)-9
+ b(al)51 b(0x100d15740\))324 6963 y(\(n10\))g(sethi)g(\045lm\(\),)
+ e(\045reg\(v)-9 b(al)51 b(0x100d18100\))324 7145 y(\(n12\))g(sllx)f
+ (\045reg\(v)-9 b(al)51 b(0x100d15740\),)e(32,)i(\045reg\(v)-9
+ b(al)51 b(0x100d157e0\))324 7328 y(\(n13\))g(or)g(\045reg\(v)-9
+ b(al)51 b(0x100d18100\),)e(\045reg\(v)-9 b(al)51 b(0x100d157e0\),)f
+ (\045reg\(v)-9 b(al)51 b(0x100d15880\))324 7511 y(\(n19\))g(or)g
+ (\045reg\(v)-9 b(al)51 b(0x100d15880\),)e(\045lo\(\),)g
+ (\045reg\(v)-9 b(al)52 b(0x100d12ec0\))324 7693 y(\(n22\))f(ld)g
+ (\045reg\(v)-9 b(al)51 b(0x100d12ec0\),)f(0,)h(\045reg\(v)-9
+ b(al)51 b(0x100d17fc0\))324 7876 y(\(n34\))g(fm)l(uls)f(\045reg\(v)-9
+ b(al)51 b(0x100bb9bf0)g(tmp.11\),)f(\045reg\(v)-9 b(al)51
+ b(0x100d17fc0\),)f(\045reg\(v)-9 b(al)51 b(0x100bb9c70)g(tmp.12\))162
+ 8059 y Ff(store)59 b(\015oat)g(\045tmp.12,)i(\015oat*)f(\045tmp.6)324
+ 8241 y Fs(\(n35\))51 b(st)f(\045reg\(v)-9 b(al)51 b(0x100bb9c70)g
+ (tmp.12\),)f(\045reg\(v)-9 b(al)51 b(0x100bb7460)f(addrOfGlobal:A1\),)g
+ (\045reg\(v)-9 b(al)51 b(0x100d318b0\))162 8424 y Ff(\045indv)-10
+ b(ar.next)61 b(=)e(add)g(uin)-5 b(t)59 b(\045i.0.0,)i(1)324
+ 8607 y Fs(\(n28\))51 b(add)g(\045reg\(v)-9 b(al)52 b(0x100baf6a0)d
+ (i.0.0\),)h(1,)g(\045reg\(v)-9 b(al)51 b(0x100cfb200)g(maskHi\))324
+ 8789 y(\(n30\))g(srl)f(\045reg\(v)-9 b(al)51 b(0x100cfb200)g(maskHi\),)
+ f(0,)g(\045reg\(v)-9 b(al)51 b(0x100bb9e40)g(indv)-9
+ b(ar.next\))162 8972 y Ff(\045exitcond)60 b(=)f(seteq)g(uin)-5
+ b(t)59 b(\045indv)-10 b(ar.next,)61 b(500)324 9155 y
+ Fs(\(n33\))51 b(sub)t(cc)h(\045reg\(v)-9 b(al)51 b(0x100bb9e40)g(indv)
+ -9 b(ar.next\),)51 b(500,)g(\045g0,)f(\045ccreg\(v)-9
+ b(al)52 b(0x100d343f0\))162 9337 y Ff(br)59 b(b)5 b(o)g(ol)60
+ b(\045exitcond,)h(lab)5 b(el)59 b(\045lo)5 b(op)g(exit,)61
+ b(lab)5 b(el)59 b(\045no)p 3777 9337 V 65 w(exit)324
+ 9520 y Fs(\(n36\))51 b(b)t(e)h(\045ccreg\(v)-9 b(al)52
+ b(0x100d343f0\),)d(\045disp\(lab)t(el)i(lo)t(op)t(exit\))324
+ 9703 y(\(n37\))g(ba)g(\045disp\(lab)t(el)g(no)p 1951
+ 9703 47 7 v 55 w(exit\))1019 10476 y Fx(Figure)59 b(4.3:)80
+ b(LL)-20 b(VM)60 b(Instructions)e(and)j(Corresp)5 b(onding)60
+ b(Mac)-5 b(hine)59 b(Instructions)3809 11136 y(26)p eop
+ end
+ %%Page: 27 34
+ TeXDict begin 27 33 bop 0 183 a Ft(4.2)270 b(Data)89
+ b(Dep)7 b(endence)90 b(Graph)h(Construction)0 728 y Fx(Swing)59
+ b(Mo)5 b(dulo)59 b(Sc)-5 b(heduling)58 b(b)5 b(egins)58
+ b(b)-5 b(y)59 b(constructing)f(the)h(Data)g(Dep)5 b(endence)59
+ b(Graph)g(\(DDG\))f(for)h(a)h(single)0 1093 y(basic)k(blo)5
+ b(c)-5 b(k)64 b(without)g(con)-5 b(trol)63 b(\015o)-5
+ b(w)65 b(or)g(calls.)92 b(The)65 b(DDG)f(consists)f(of)h(no)5
+ b(des)64 b(that)g(represen)-5 b(t)64 b(instructions)7723
+ 1027 y Fo(1)0 1459 y Fx(and)42 b(their)f(corresp)5 b(onding)40
+ b(prop)5 b(erties,)44 b(and)e(edges)f(that)g(represen)-5
+ b(t)41 b(the)g(true,)k(an)-5 b(ti,)44 b(and)e(output)f(dep)5
+ b(endencies)0 1824 y(in)60 b(the)g(lo)5 b(op.)282 2190
+ y(Our)68 b(implemen)-5 b(tation)63 b(only)j(constructs)f(a)i(DDG)f(for)
+ h(the)f(instructions)f(deemed)g(to)i(b)5 b(e)66 b(the)h(lo)5
+ b(op)66 b(b)5 b(o)g(dy)-15 b(.)0 2555 y(This)64 b(excludes)e
+ (instructions)g(related)h(to)h(the)g(iteration)e(coun)-5
+ b(t)63 b(and)h(branc)-5 b(h.)91 b(The)64 b(SMS)g(algorithm)e(\(or)i(an)
+ -5 b(y)0 2920 y(Mo)5 b(dulo)74 b(Sc)-5 b(heduling)73
+ b(algorithm\))g(has)h(no)h(mec)-5 b(hanism)73 b(to)h(ensure)h(that)f
+ (these)g(excluded)f(instructions)g(are)0 3286 y(from)47
+ b(the)h(curren)-5 b(t)48 b(iteration,)g(stage)f(0,)j(in)e(the)g
+ (resulting)e(k)-5 b(ernel.)75 b(Keeping)48 b(these)f(instructions)f(in)
+ i(the)f(curren)-5 b(t)0 3651 y(iteration)39 b(is)h(critical)f(to)h
+ (prop)5 b(er)41 b(execution)e(of)h(the)h(lo)5 b(op.)73
+ b(These)40 b(excluded)g(instructions)e(are)j(reinserted)e(during)0
+ 4016 y(the)60 b(lo)5 b(op)60 b(reconstruction)f(phase)h(describ)5
+ b(ed)60 b(in)g(Section)f(4.7.)282 4382 y(The)d(DDG)f(construction)f
+ (examines)f(eac)-5 b(h)55 b(instruction)f(of)h(the)g(lo)5
+ b(op)55 b(b)5 b(o)g(dy)55 b(and)h(determines)d(its)i(relation-)0
+ 4747 y(ship)61 b(b)5 b(et)-5 b(w)g(een)60 b(all)h(other)f
+ (instructions.)81 b(Eac)-5 b(h)60 b(edge)h(in)g(the)g(DDG)g(represen)-5
+ b(ts)60 b(a)h(data)g(dep)5 b(endence)61 b(b)5 b(et)-5
+ b(w)g(een)0 5113 y(the)60 b(t)-5 b(w)g(o)61 b(instructions.)78
+ b(There)60 b(are)h(three)f(t)-5 b(yp)5 b(es)60 b(of)g(dep)5
+ b(endencies)59 b(in)h(the)g(DDG:)273 5604 y Fr(\017)91
+ b Fx(T)-15 b(rue)72 b(Dep)5 b(endence:)104 b(If)71 b(the)h(\014rst)h
+ (instruction)d(writes)i(to)g(a)h(v)-10 b(alue,)74 b(and)e(a)h(second)f
+ (instruction)e(reads)455 5970 y(the)60 b(same)f(v)-10
+ b(alue,)59 b(there)i(is)e(a)i(true)f(dep)5 b(endence)60
+ b(from)g(the)g(\014rst)g(instruction)f(to)h(the)g(second.)273
+ 6460 y Fr(\017)91 b Fx(An)-5 b(ti)77 b(Dep)5 b(endence:)115
+ b(If)77 b(the)h(\014rst)g(instruction)e(reads)i(a)g(v)-10
+ b(alue,)82 b(and)c(a)g(second)f(instruction)g(writes)g(a)455
+ 6825 y(v)-10 b(alue,)59 b(then)h(there)g(is)g(an)g(an)-5
+ b(ti)60 b(dep)5 b(endence)60 b(from)g(the)g(\014rst)g(instruction)f(to)
+ h(the)g(second.)273 7316 y Fr(\017)91 b Fx(Output)49
+ b(Dep)5 b(endence:)74 b(If)49 b(t)-5 b(w)g(o)49 b(instructions)e(b)5
+ b(oth)50 b(write)f(to)g(the)g(same)g(v)-10 b(alue,)50
+ b(then)f(there)g(is)g(an)h(output)455 7681 y(dep)5 b(endence)59
+ b(b)5 b(et)-5 b(w)g(een)60 b(them.)282 8173 y(Eac)-5
+ b(h)45 b(dep)5 b(endence)45 b(has)g(a)h(distance)e(asso)5
+ b(ciated)43 b(with)i(it,)i(called)e(the)g(iteration)e(di\013erence.)75
+ b(If)44 b(the)i(distance)0 8538 y(is)54 b(zero,)h(this)f(means)f(the)i
+ (dep)5 b(endence)53 b(is)h(a)h(lo)5 b(op-indep)g(enden)-5
+ b(t)52 b(dep)5 b(endence,)55 b(in)f(other)g(w)-5 b(ords)55
+ b(a)g(dep)5 b(endence)0 8903 y(within)67 b(one)g(iteration.)99
+ b(If)67 b(the)g(distance)f(is)g(greater)h(than)h(zero,)g(there)f(is)g
+ (a)g(dep)5 b(endence)67 b(across)g(iterations,)0 9269
+ y(a)j(lo)5 b(op-carried)69 b(dep)5 b(endence.)110 b(The)70
+ b(v)-10 b(alue)70 b(of)g(the)g(distance)f(for)h(lo)5
+ b(op-carried)69 b(dep)5 b(endences)69 b(is)h(one,)i(unless)0
+ 9634 y(further)60 b(analysis)f(can)h(pro)-5 b(v)g(e)61
+ b(the)f(actual)f(n)-5 b(um)g(b)5 b(er)60 b(of)g(iterations)f(b)5
+ b(et)-5 b(w)g(een)60 b(the)g(instructions.)282 10000
+ y(Dep)5 b(endences)72 b(are)g(generated)g(for)g(all)f(mac)-5
+ b(hine)71 b(registers,)j(memory)d(instructions,)i(and)g(LL)-20
+ b(VM)71 b(v)-10 b(alues)0 10365 y(\(b)5 b(oth)55 b(describ)5
+ b(ed)54 b(in)h(Section)g(4.1\).)77 b(Lo)5 b(op-carried)54
+ b(dep)5 b(endences)55 b(exist)f(for)h(memory)g(and)g(an)-5
+ b(y)56 b(LL)-20 b(VM)54 b(v)-10 b(alues)p 0 10509 3120
+ 7 v 207 10617 a Fl(1)276 10680 y Fs(All)51 b(references)i(to)e
+ (instruction)f(mean)i(the)f(lo)l(w-lev)l(el)g(Mac)l(hine)g(Instruction)
+ h(represen)l(tation)f(in)g(the)h(SP)-13 b(AR)l(C)51 b(bac)l(k-end.)3809
+ 11136 y Fx(27)p eop end
+ %%Page: 28 35
+ TeXDict begin 28 34 bop 0 183 a Fx(or)50 b(mac)-5 b(hine)48
+ b(registers)h(that)g(are)h(liv)-5 b(e)49 b(across)g(iterations.)74
+ b(LL)-20 b(VM)49 b(v)-10 b(alues)49 b(that)g(are)h(liv)-5
+ b(e)49 b(across)g(iterations)f(w)-5 b(ere)0 548 y(originally)57
+ b(represen)-5 b(ted)58 b(as)g Fq(\036)2096 482 y Fo(2)2234
+ 548 y Fx(instructions)f(at)h(the)h(LL)-20 b(VM)58 b(lev)-5
+ b(el.)78 b(Because)58 b(SMS)g(is)g(op)5 b(erating)58
+ b(on)h(a)g(lo)-5 b(w)g(er-)0 913 y(lev)g(el)69 b(represen)-5
+ b(tation,)70 b(it)f(m)-5 b(ust)69 b(determine)g(whic)-5
+ b(h)69 b(mac)-5 b(hine)69 b(instructions)f(w)-5 b(ere)70
+ b(generated)f(b)-5 b(y)70 b(the)g(LL)-20 b(VM)0 1279
+ y Fq(\036)60 b Fx(instruction.)78 b(Tw)-5 b(o)60 b(cop)-5
+ b(y)60 b(instructions)d(lo)5 b(cated)59 b(at)g(the)h(start)f(and)g(end)
+ h(of)f(the)g(basic)g(blo)5 b(c)-5 b(k)59 b(are)h(generated)0
+ 1644 y(for)k(eac)-5 b(h)64 b Fq(\036)h Fx(instruction.)90
+ b(There)65 b(is)e(a)i(true-dep)5 b(endence)63 b(from)g(the)h(last)g
+ (instruction)e(related)i(to)g(the)g Fq(\036)p Fx(,)h(and)0
+ 2010 y(the)58 b(\014rst)h(instruction)e(with)h(a)h(distance)e(of)h
+ (one.)80 b(Memory)58 b(instructions)e(ha)-5 b(v)g(e)59
+ b(lo)5 b(op-carried)57 b(dep)5 b(endences)58 b(of)0 2375
+ y(distance)f(one,)h(and)h(the)f(dep)5 b(endence)58 b(t)-5
+ b(yp)5 b(e)58 b(is)g(determined)f(b)-5 b(y)58 b(the)h(t)-5
+ b(yp)5 b(es)57 b(of)h(the)h(t)-5 b(w)g(o)58 b(instructions)e(in)-5
+ b(v)g(olv)g(ed)0 2740 y(\(load)72 b(or)i(store\).)117
+ b(Simple)72 b(dep)5 b(endence)72 b(analysis)g(is)g(used)h(to)g
+ (eliminate)e(man)-5 b(y)72 b(of)h(these)f(dep)5 b(endences,)75
+ b(b)-5 b(y)0 3106 y(examining)68 b(the)i(memory)g(p)5
+ b(oin)-5 b(ters)69 b(and)h(determining)f(if)g(the)h(same)f(memory)g(is)
+ h(b)5 b(eing)70 b(accessed.)108 b(A)71 b(more)0 3471
+ y(sophisticated)63 b(dep)5 b(endence)65 b(analysis)g(\(Section)f
+ (4.2.1\))g(is)i(used)f(to)h(determine)e(the)i(actual)e(distance)h(for)g
+ (the)0 3836 y(dep)5 b(endencies.)282 4202 y(Figure)61
+ b(4.4)h(is)f(the)g(dep)5 b(endence)61 b(graph)h(for)g(the)f(example)f
+ (lo)5 b(op.)84 b(Eac)-5 b(h)61 b(no)5 b(de)62 b(in)f(the)h(graph)g
+ (corresp)5 b(onds)0 4567 y(to)76 b(an)h(instruction)e(in)h(the)h(lo)5
+ b(op)76 b(b)5 b(o)g(dy)-15 b(.)128 b(The)77 b(edges)f(b)5
+ b(et)-5 b(w)g(een)76 b(the)h(no)5 b(des)76 b(are)h(the)f(dep)5
+ b(endences)76 b(b)5 b(et)-5 b(w)g(een)0 4933 y(the)56
+ b(instructions.)77 b(Eac)-5 b(h)56 b(dep)5 b(endence)55
+ b(is)h(mark)-5 b(ed)56 b(with)g(its)f(t)-5 b(yp)5 b(e,)56
+ b(and)h(the)f(distance)f(\(if)g(greater)h(than)g(zero\).)0
+ 5298 y(The)50 b(dep)5 b(endence)50 b(graph)g(for)g(our)g(example)e
+ (mostly)h(has)h(true)g(dep)5 b(endences)49 b(b)5 b(ecause)49
+ b(our)h(co)5 b(de)50 b(is)f(in)h(SSA[11)o(])0 5663 y(and)65
+ b(no)f(v)-10 b(alue)64 b(is)g(de\014ned)h(more)f(than)h(once.)92
+ b(Additionally)-15 b(,)63 b(there)h(are)h(lo)5 b(op-carried)63
+ b(dep)5 b(endences)64 b(\(with)g(a)0 6029 y(distance)59
+ b(of)h(one\))g(b)5 b(et)-5 b(w)g(een)60 b(all)g(loads)f(and)i(stores)f
+ (that)g(w)-5 b(ere)60 b(pro)-5 b(v)g(en)61 b(to)f(access)f(the)h(same)g
+ (memory)-15 b(.)0 6659 y Fk(4.2.1)225 b(Dep)6 b(endence)74
+ b(Analysis)0 7142 y Fx(Simple)69 b(dep)5 b(endence)71
+ b(analysis)e(eliminates)f(man)-5 b(y)70 b(dep)5 b(endencies)70
+ b(b)5 b(et)-5 b(w)g(een)70 b(loads)h(and)g(stores)f(but)h(can)f(not)0
+ 7507 y(determine)56 b(the)g(actual)g(distance)g(for)h(lo)5
+ b(op-carried)55 b(dep)5 b(endencies.)78 b(Assuming)56
+ b(a)h(distance)e(of)i(one)g(is)f(conser-)0 7873 y(v)-10
+ b(ativ)-5 b(e)63 b(and)h(results)e(in)i(man)-5 b(y)63
+ b(missed)g(opp)5 b(ortunities)62 b(for)i(parallelism.)87
+ b(Our)65 b(implemen)-5 b(tation)60 b(uses)k(a)g(more)0
+ 8238 y(sophisticated)58 b(analysis)h(to)h(calculate)f(the)h(actual)f
+ (distances)g(for)h(lo)5 b(op-carried)59 b(dep)5 b(endences.)282
+ 8604 y(W)-15 b(e)45 b(implemen)-5 b(ted)43 b(a)i(Dep)5
+ b(endence)44 b(Analyzer)h(that)g(uses)g(t)-5 b(w)g(o)45
+ b(analyses,)h Fu(Alias)f(Analysis)f Fx(\(AA\))h(and)h
+ Fu(Scalar)0 8969 y(Ev)-5 b(olution)78 b Fx(\(SE\),)g(whic)-5
+ b(h)80 b(are)f(b)5 b(oth)80 b(pro)-5 b(vided)79 b(b)-5
+ b(y)79 b(the)h(LL)-20 b(VM)79 b(compiler)f(infrastructure.)136
+ b(Alias)78 b(Analysis)0 9334 y(pro)-5 b(vides)63 b(information)g(ab)5
+ b(out)63 b(the)h(p)5 b(oin)-5 b(ts-to)63 b(relationship)f(for)i
+ (references)f(in)h(the)g(program,)g(whic)-5 b(h)64 b(it)g(ma)-5
+ b(y)0 9700 y(decide)50 b(is)h(a)h(ma)-5 b(y/m)g(ust/no)49
+ b(relation.)76 b(The)51 b(Scalar)g(Ev)-5 b(olution)50
+ b(analysis)g(uses)g(Chains)h(of)g(Recurrences)g(\(CRs\))0
+ 10065 y(as)60 b(a)h(w)-5 b(a)g(y)60 b(of)h(represen)-5
+ b(ting)59 b(the)h(\014xed)g(relation)f(b)5 b(et)-5 b(w)g(een)60
+ b(t)-5 b(w)g(o)61 b(memory)e(references)h([7)o(,)g(40,)g(39,)g(43,)g
+ (6].)p 0 10233 3120 7 v 207 10341 a Fl(2)276 10404 y
+ Fs(A)c Fm(\036)f Fs(instruction)g([11)o(])g(is)f(a)h(merge)h(p)t(oin)l
+ (t)f(for)g(a)g(v)-9 b(ariable,)56 b(where)g(it)e(has)h(as)g(man)l(y)g
+ (op)t(erands)h(as)e(there)i(are)f(v)l(ersions)g(of)g(the)0
+ 10587 y(v)-9 b(ariable.)3809 11136 y Fx(28)p eop end
+ %%Page: 29 36
+ TeXDict begin 29 35 bop 0 866 a
+  29246476 33633443 2302361 2302361 42495016 48744284 startTexFig
+  0 866 a
+ %%BeginDocument: figs/loopExample-DepGraph2.ps
+ %!PS-Adobe-2.0
+ %%Creator: dot version 1.9 (Thu Feb 13 13:41:01 CST 2003)
+ %%For: (tbrethou) Tanya Brethour
+ %%Title: foo
+ %%Pages: (atend)
+ %%BoundingBox: 35 35 646 741
+ %%EndComments
+ save
+ %%BeginProlog
+ /DotDict 200 dict def
+ DotDict begin
+ 
+ /setupLatin1 {
+ mark
+ /EncodingVector 256 array def
+  EncodingVector 0
+ 
+ ISOLatin1Encoding 0 255 getinterval putinterval
+ 
+ EncodingVector
+   dup 306 /AE
+   dup 301 /Aacute
+   dup 302 /Acircumflex
+   dup 304 /Adieresis
+   dup 300 /Agrave
+   dup 305 /Aring
+   dup 303 /Atilde
+   dup 307 /Ccedilla
+   dup 311 /Eacute
+   dup 312 /Ecircumflex
+   dup 313 /Edieresis
+   dup 310 /Egrave
+   dup 315 /Iacute
+   dup 316 /Icircumflex
+   dup 317 /Idieresis
+   dup 314 /Igrave
+   dup 334 /Udieresis
+   dup 335 /Yacute
+   dup 376 /thorn
+   dup 337 /germandbls
+   dup 341 /aacute
+   dup 342 /acircumflex
+   dup 344 /adieresis
+   dup 346 /ae
+   dup 340 /agrave
+   dup 345 /aring
+   dup 347 /ccedilla
+   dup 351 /eacute
+   dup 352 /ecircumflex
+   dup 353 /edieresis
+   dup 350 /egrave
+   dup 355 /iacute
+   dup 356 /icircumflex
+   dup 357 /idieresis
+   dup 354 /igrave
+   dup 360 /dcroat
+   dup 361 /ntilde
+   dup 363 /oacute
+   dup 364 /ocircumflex
+   dup 366 /odieresis
+   dup 362 /ograve
+   dup 365 /otilde
+   dup 370 /oslash
+   dup 372 /uacute
+   dup 373 /ucircumflex
+   dup 374 /udieresis
+   dup 371 /ugrave
+   dup 375 /yacute
+   dup 377 /ydieresis  
+ 
+ % Set up ISO Latin 1 character encoding
+ /starnetISO {
+         dup dup findfont dup length dict begin
+         { 1 index /FID ne { def }{ pop pop } ifelse
+         } forall
+         /Encoding EncodingVector def
+         currentdict end definefont
+ } def
+ /Times-Roman starnetISO def
+ /Times-Italic starnetISO def
+ /Times-Bold starnetISO def
+ /Times-BoldItalic starnetISO def
+ /Helvetica starnetISO def
+ /Helvetica-Oblique starnetISO def
+ /Helvetica-Bold starnetISO def
+ /Helvetica-BoldOblique starnetISO def
+ /Courier starnetISO def
+ /Courier-Oblique starnetISO def
+ /Courier-Bold starnetISO def
+ /Courier-BoldOblique starnetISO def
+ cleartomark
+ } bind def
+ 
+ %%BeginResource: procset
+ /coord-font-family /Times-Roman def
+ /default-font-family /Times-Roman def
+ /coordfont coord-font-family findfont 8 scalefont def
+ 
+ /InvScaleFactor 1.0 def
+ /set_scale {
+ 	dup 1 exch div /InvScaleFactor exch def
+ 	dup scale
+ } bind def
+ 
+ % styles
+ /solid { [] 0 setdash } bind def
+ /dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+ /dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+ /invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+ /bold { 2 setlinewidth } bind def
+ /filled { } bind def
+ /unfilled { } bind def
+ /rounded { } bind def
+ /diagonals { } bind def
+ 
+ % hooks for setting color 
+ /nodecolor { sethsbcolor } bind def
+ /edgecolor { sethsbcolor } bind def
+ /graphcolor { sethsbcolor } bind def
+ /nopcolor {pop pop pop} bind def
+ 
+ /beginpage {	% i j npages
+ 	/npages exch def
+ 	/j exch def
+ 	/i exch def
+ 	/str 10 string def
+ 	npages 1 gt {
+ 		gsave
+ 			coordfont setfont
+ 			0 0 moveto
+ 			(\() show i str cvs show (,) show j str cvs show (\)) show
+ 		grestore
+ 	} if
+ } bind def
+ 
+ /set_font {
+ 	findfont exch
+ 	scalefont setfont
+ } def
+ 
+ % draw aligned label in bounding box aligned to current point
+ /alignedtext {			% width adj text
+ 	/text exch def
+ 	/adj exch def
+ 	/width exch def
+ 	gsave
+ 		width 0 gt {
+ 			text stringwidth pop adj mul 0 rmoveto
+ 		} if
+ 		[] 0 setdash
+ 		text show
+ 	grestore
+ } def
+ 
+ /boxprim {				% xcorner ycorner xsize ysize
+ 		4 2 roll
+ 		moveto
+ 		2 copy
+ 		exch 0 rlineto
+ 		0 exch rlineto
+ 		pop neg 0 rlineto
+ 		closepath
+ } bind def
+ 
+ /ellipse_path {
+ 	/ry exch def
+ 	/rx exch def
+ 	/y exch def
+ 	/x exch def
+ 	matrix currentmatrix
+ 	newpath
+ 	x y translate
+ 	rx ry scale
+ 	0 0 1 0 360 arc
+ 	setmatrix
+ } bind def
+ 
+ /endpage { showpage } bind def
+ /showpage { } def
+ 
+ /layercolorseq
+ 	[	% layer color sequence - darkest to lightest
+ 		[0 0 0]
+ 		[.2 .8 .8]
+ 		[.4 .8 .8]
+ 		[.6 .8 .8]
+ 		[.8 .8 .8]
+ 	]
+ def
+ 
+ /layerlen layercolorseq length def
+ 
+ /setlayer {/maxlayer exch def /curlayer exch def
+ 	layercolorseq curlayer 1 sub layerlen mod get
+ 	aload pop sethsbcolor
+ 	/nodecolor {nopcolor} def
+ 	/edgecolor {nopcolor} def
+ 	/graphcolor {nopcolor} def
+ } bind def
+ 
+ /onlayer { curlayer ne {invis} if } def
+ 
+ /onlayers {
+ 	/myupper exch def
+ 	/mylower exch def
+ 	curlayer mylower lt
+ 	curlayer myupper gt
+ 	or
+ 	{invis} if
+ } def
+ 
+ /curlayer 0 def
+ 
+ %%EndResource
+ %%EndProlog
+ %%BeginSetup
+ 14 default-font-family set_font
+ 1 setmiterlimit
+ % /arrowlength 10 def
+ % /arrowwidth 5 def
+ 
+ % make sure pdfmark is harmless for PS-interpreters other than Distiller
+ /pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+ % make '<<' and '>>' safe on PS Level 1 devices
+ /languagelevel where {pop languagelevel}{1} ifelse
+ 2 lt {
+     userdict (<<) cvn ([) cvn load put
+     userdict (>>) cvn ([) cvn load put
+ } if
+ 
+ %%EndSetup
+ %%Page: 1 1
+ %%PageBoundingBox: 36 36 646 741
+ %%PageOrientation: Portrait
+ gsave
+ 35 35 611 706 boxprim clip newpath
+ 36 36 translate
+ 0 0 1 beginpage
+ 0 0 translate 0 rotate
+ 0.000 0.000 0.000 graphcolor
+ 14.00 /Times-Roman set_font
+ gsave 10 dict begin
+ 304 5 moveto 133 -0.5 (Dependence Graph) alignedtext
+ end grestore
+ 
+ %	Node0x100bb8e40
+ gsave 10 dict begin
+ newpath 523 256 moveto
+ 591 256 lineto
+ 591 296 lineto
+ 523 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 557 281 moveto 54 -0.5 (sll \(n26\)) alignedtext
+ end grestore
+ newpath 523 276 moveto
+ 591 276 lineto
+ stroke
+ gsave 10 dict begin
+ 557 261 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb9020
+ gsave 10 dict begin
+ newpath 431 180 moveto
+ 494 180 lineto
+ 494 220 lineto
+ 431 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 462 205 moveto 49 -0.5 (st \(n35\)) alignedtext
+ end grestore
+ newpath 431 200 moveto
+ 494 200 lineto
+ stroke
+ gsave 10 dict begin
+ 462 185 moveto 44 -0.5 (Anti[1]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8e40 -> Node0x100bb9020
+ newpath 543 256 moveto
+ 531 248 514 237 499 226 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 500 224 moveto
+ 491 220 lineto
+ 498 228 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8de0
+ gsave 10 dict begin
+ newpath 344 104 moveto
+ 410 104 lineto
+ 410 144 lineto
+ 344 144 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 377 129 moveto 52 -0.5 (ld \(n25\)) alignedtext
+ end grestore
+ newpath 344 124 moveto
+ 410 124 lineto
+ stroke
+ gsave 10 dict begin
+ 377 109 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb9020 -> Node0x100bb8de0
+ newpath 449 180 moveto
+ 439 173 424 161 411 150 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 412 148 moveto
+ 403 144 lineto
+ 410 152 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8fc0
+ gsave 10 dict begin
+ newpath 330 28 moveto
+ 424 28 lineto
+ 424 68 lineto
+ 330 68 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 377 53 moveto 80 -0.5 (fmuls \(n34\)) alignedtext
+ end grestore
+ newpath 330 48 moveto
+ 424 48 lineto
+ stroke
+ gsave 10 dict begin
+ 377 33 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8de0 -> Node0x100bb8fc0
+ newpath 377 104 moveto
+ 377 98 377 88 377 79 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 380 78 moveto
+ 377 68 lineto
+ 375 78 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8fc0 -> Node0x100bb9020
+ newpath 451 172 moveto
+ 443 153 431 126 419 104 curveto
+ 408 83 393 61 384 48 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 448 172 moveto
+ 454 180 lineto
+ 453 170 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8b40
+ gsave 10 dict begin
+ newpath 345 180 moveto
+ 409 180 lineto
+ 409 220 lineto
+ 345 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 377 205 moveto 50 -0.5 (sll \(n18\)) alignedtext
+ end grestore
+ newpath 345 200 moveto
+ 409 200 lineto
+ stroke
+ gsave 10 dict begin
+ 377 185 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8b40 -> Node0x100bb8de0
+ newpath 377 180 moveto
+ 377 174 377 164 377 155 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 380 154 moveto
+ 377 144 lineto
+ 375 154 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8c60
+ gsave 10 dict begin
+ newpath 251 180 moveto
+ 327 180 lineto
+ 327 220 lineto
+ 251 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 289 205 moveto 62 -0.5 (add \(n21\)) alignedtext
+ end grestore
+ newpath 251 200 moveto
+ 327 200 lineto
+ stroke
+ gsave 10 dict begin
+ 289 185 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8c60 -> Node0x100bb8de0
+ newpath 302 180 moveto
+ 313 172 328 161 342 150 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 344 152 moveto
+ 350 144 lineto
+ 340 148 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb85a0
+ gsave 10 dict begin
+ newpath 161 560 moveto
+ 238 560 lineto
+ 238 600 lineto
+ 161 600 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 199 585 moveto 63 -0.5 (sethi \(n2\)) alignedtext
+ end grestore
+ newpath 161 580 moveto
+ 238 580 lineto
+ stroke
+ gsave 10 dict begin
+ 199 565 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8660
+ gsave 10 dict begin
+ newpath 168 484 moveto
+ 231 484 lineto
+ 231 524 lineto
+ 168 524 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 199 509 moveto 45 -0.5 (or \(n5\)) alignedtext
+ end grestore
+ newpath 168 504 moveto
+ 231 504 lineto
+ stroke
+ gsave 10 dict begin
+ 199 489 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb85a0 -> Node0x100bb8660
+ newpath 199 560 moveto
+ 199 554 199 544 199 535 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 202 534 moveto
+ 199 524 lineto
+ 197 534 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb88a0
+ gsave 10 dict begin
+ newpath 163 408 moveto
+ 233 408 lineto
+ 233 448 lineto
+ 163 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 198 433 moveto 56 -0.5 (sllx \(n11\)) alignedtext
+ end grestore
+ newpath 163 428 moveto
+ 233 428 lineto
+ stroke
+ gsave 10 dict begin
+ 198 413 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8660 -> Node0x100bb88a0
+ newpath 199 484 moveto
+ 199 477 199 467 199 457 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 202 458 moveto
+ 198 448 lineto
+ 197 458 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8a20
+ gsave 10 dict begin
+ newpath 257 332 moveto
+ 321 332 lineto
+ 321 372 lineto
+ 257 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 289 357 moveto 50 -0.5 (or \(n15\)) alignedtext
+ end grestore
+ newpath 257 352 moveto
+ 321 352 lineto
+ stroke
+ gsave 10 dict begin
+ 289 337 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb88a0 -> Node0x100bb8a20
+ newpath 212 408 moveto
+ 223 400 239 389 253 378 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 255 380 moveto
+ 261 372 lineto
+ 251 376 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8ae0
+ gsave 10 dict begin
+ newpath 257 256 moveto
+ 322 256 lineto
+ 322 296 lineto
+ 257 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 289 281 moveto 51 -0.5 (or \(n17\)) alignedtext
+ end grestore
+ newpath 257 276 moveto
+ 322 276 lineto
+ stroke
+ gsave 10 dict begin
+ 289 261 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8a20 -> Node0x100bb8ae0
+ newpath 289 332 moveto
+ 289 326 289 316 289 307 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 292 306 moveto
+ 289 296 lineto
+ 287 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb86c0
+ gsave 10 dict begin
+ newpath 251 408 moveto
+ 328 408 lineto
+ 328 448 lineto
+ 251 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 289 433 moveto 63 -0.5 (sethi \(n6\)) alignedtext
+ end grestore
+ newpath 251 428 moveto
+ 328 428 lineto
+ stroke
+ gsave 10 dict begin
+ 289 413 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb86c0 -> Node0x100bb8a20
+ newpath 289 408 moveto
+ 289 402 289 392 289 383 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 292 382 moveto
+ 289 372 lineto
+ 287 382 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8ae0 -> Node0x100bb8c60
+ newpath 289 256 moveto
+ 289 250 289 240 289 231 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 292 230 moveto
+ 289 220 lineto
+ 287 230 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb87e0
+ gsave 10 dict begin
+ newpath 341 332 moveto
+ 411 332 lineto
+ 411 372 lineto
+ 341 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 376 357 moveto 56 -0.5 (add \(n9\)) alignedtext
+ end grestore
+ newpath 341 352 moveto
+ 411 352 lineto
+ stroke
+ gsave 10 dict begin
+ 376 337 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8a80
+ gsave 10 dict begin
+ newpath 343 256 moveto
+ 409 256 lineto
+ 409 296 lineto
+ 343 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 376 281 moveto 52 -0.5 (srl \(n16\)) alignedtext
+ end grestore
+ newpath 343 276 moveto
+ 409 276 lineto
+ stroke
+ gsave 10 dict begin
+ 376 261 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb87e0 -> Node0x100bb8a80
+ newpath 376 332 moveto
+ 376 326 376 316 376 307 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 379 306 moveto
+ 376 296 lineto
+ 374 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8a80 -> Node0x100bb8b40
+ newpath 376 256 moveto
+ 376 249 376 240 376 230 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 378 230 moveto
+ 377 220 lineto
+ 374 230 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8540
+ gsave 10 dict begin
+ newpath 338 484 moveto
+ 411 484 lineto
+ 411 524 lineto
+ 338 524 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 374 509 moveto 59 -0.5 (sethi \(n1\)) alignedtext
+ end grestore
+ newpath 338 504 moveto
+ 411 504 lineto
+ stroke
+ gsave 10 dict begin
+ 374 489 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8780
+ gsave 10 dict begin
+ newpath 345 408 moveto
+ 408 408 lineto
+ 408 448 lineto
+ 345 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 376 433 moveto 45 -0.5 (or \(n8\)) alignedtext
+ end grestore
+ newpath 345 428 moveto
+ 408 428 lineto
+ stroke
+ gsave 10 dict begin
+ 376 413 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8540 -> Node0x100bb8780
+ newpath 374 484 moveto
+ 375 477 375 468 375 458 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 378 458 moveto
+ 375 448 lineto
+ 373 458 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8780 -> Node0x100bb87e0
+ newpath 376 408 moveto
+ 376 402 376 392 376 383 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 379 382 moveto
+ 376 372 lineto
+ 374 382 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8600
+ gsave 10 dict begin
+ newpath 74 484 moveto
+ 151 484 lineto
+ 151 524 lineto
+ 74 524 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 112 509 moveto 63 -0.5 (sethi \(n4\)) alignedtext
+ end grestore
+ newpath 74 504 moveto
+ 151 504 lineto
+ stroke
+ gsave 10 dict begin
+ 112 489 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8720
+ gsave 10 dict begin
+ newpath 82 408 moveto
+ 145 408 lineto
+ 145 448 lineto
+ 82 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 113 433 moveto 46 -0.5 (or \(n7\)) alignedtext
+ end grestore
+ newpath 82 428 moveto
+ 145 428 lineto
+ stroke
+ gsave 10 dict begin
+ 113 413 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8600 -> Node0x100bb8720
+ newpath 112 484 moveto
+ 112 477 112 468 112 458 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 114 458 moveto
+ 113 448 lineto
+ 110 458 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8900
+ gsave 10 dict begin
+ newpath 98 332 moveto
+ 172 332 lineto
+ 172 372 lineto
+ 98 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 135 357 moveto 60 -0.5 (sllx \(n12\)) alignedtext
+ end grestore
+ newpath 98 352 moveto
+ 172 352 lineto
+ stroke
+ gsave 10 dict begin
+ 135 337 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8720 -> Node0x100bb8900
+ newpath 116 408 moveto
+ 118 401 122 391 125 382 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 128 382 moveto
+ 128 372 lineto
+ 123 381 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8960
+ gsave 10 dict begin
+ newpath 103 256 moveto
+ 167 256 lineto
+ 167 296 lineto
+ 103 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 135 281 moveto 50 -0.5 (or \(n13\)) alignedtext
+ end grestore
+ newpath 103 276 moveto
+ 167 276 lineto
+ stroke
+ gsave 10 dict begin
+ 135 261 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8900 -> Node0x100bb8960
+ newpath 135 332 moveto
+ 135 326 135 316 135 307 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 138 306 moveto
+ 135 296 lineto
+ 133 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8ba0
+ gsave 10 dict begin
+ newpath 147 180 moveto
+ 211 180 lineto
+ 211 220 lineto
+ 147 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 179 205 moveto 50 -0.5 (or \(n19\)) alignedtext
+ end grestore
+ newpath 147 200 moveto
+ 211 200 lineto
+ stroke
+ gsave 10 dict begin
+ 179 185 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8960 -> Node0x100bb8ba0
+ newpath 142 256 moveto
+ 147 249 154 239 160 229 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 163 230 moveto
+ 166 220 lineto
+ 158 227 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8840
+ gsave 10 dict begin
+ newpath 0 332 moveto
+ 81 332 lineto
+ 81 372 lineto
+ 0 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 40 357 moveto 67 -0.5 (sethi \(n10\)) alignedtext
+ end grestore
+ newpath 0 352 moveto
+ 81 352 lineto
+ stroke
+ gsave 10 dict begin
+ 40 337 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8840 -> Node0x100bb8960
+ newpath 54 332 moveto
+ 66 324 83 313 98 302 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 100 304 moveto
+ 106 296 lineto
+ 96 300 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8cc0
+ gsave 10 dict begin
+ newpath 203 104 moveto
+ 270 104 lineto
+ 270 144 lineto
+ 203 144 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 236 129 moveto 53 -0.5 (ld \(n22\)) alignedtext
+ end grestore
+ newpath 203 124 moveto
+ 270 124 lineto
+ stroke
+ gsave 10 dict begin
+ 236 109 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8ba0 -> Node0x100bb8cc0
+ newpath 188 180 moveto
+ 194 173 204 162 212 152 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 214 153 moveto
+ 219 144 lineto
+ 211 150 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8f60
+ gsave 10 dict begin
+ newpath 427 256 moveto
+ 505 256 lineto
+ 505 296 lineto
+ 427 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 466 281 moveto 64 -0.5 (add \(n32\)) alignedtext
+ end grestore
+ newpath 427 276 moveto
+ 505 276 lineto
+ stroke
+ gsave 10 dict begin
+ 466 261 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8f60 -> Node0x100bb9020
+ newpath 465 256 moveto
+ 464 249 464 240 464 230 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 466 230 moveto
+ 463 220 lineto
+ 462 230 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8cc0 -> Node0x100bb8fc0
+ newpath 257 104 moveto
+ 276 96 302 83 326 72 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 327 74 moveto
+ 335 68 lineto
+ 325 70 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb89c0
+ gsave 10 dict begin
+ newpath 527 636 moveto
+ 609 636 lineto
+ 609 676 lineto
+ 527 676 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 568 661 moveto 68 -0.5 (sethi \(n14\)) alignedtext
+ end grestore
+ newpath 527 656 moveto
+ 609 656 lineto
+ stroke
+ gsave 10 dict begin
+ 568 641 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8c00
+ gsave 10 dict begin
+ newpath 534 560 moveto
+ 602 560 lineto
+ 602 600 lineto
+ 534 600 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 568 585 moveto 54 -0.5 (or \(n20\)) alignedtext
+ end grestore
+ newpath 534 580 moveto
+ 602 580 lineto
+ stroke
+ gsave 10 dict begin
+ 568 565 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb89c0 -> Node0x100bb8c00
+ newpath 568 636 moveto
+ 568 630 568 620 568 611 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 571 610 moveto
+ 568 600 lineto
+ 566 610 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8d20
+ gsave 10 dict begin
+ newpath 530 484 moveto
+ 606 484 lineto
+ 606 524 lineto
+ 530 524 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 568 509 moveto 62 -0.5 (sllx \(n23\)) alignedtext
+ end grestore
+ newpath 530 504 moveto
+ 606 504 lineto
+ stroke
+ gsave 10 dict begin
+ 568 489 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8c00 -> Node0x100bb8d20
+ newpath 568 560 moveto
+ 568 554 568 544 568 535 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 571 534 moveto
+ 568 524 lineto
+ 566 534 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8ea0
+ gsave 10 dict begin
+ newpath 436 408 moveto
+ 504 408 lineto
+ 504 448 lineto
+ 436 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 470 433 moveto 54 -0.5 (or \(n27\)) alignedtext
+ end grestore
+ newpath 436 428 moveto
+ 504 428 lineto
+ stroke
+ gsave 10 dict begin
+ 470 413 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8d20 -> Node0x100bb8ea0
+ newpath 553 484 moveto
+ 541 476 524 465 508 454 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 509 452 moveto
+ 500 448 lineto
+ 507 456 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8f00
+ gsave 10 dict begin
+ newpath 433 332 moveto
+ 501 332 lineto
+ 501 372 lineto
+ 433 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 467 357 moveto 54 -0.5 (or \(n29\)) alignedtext
+ end grestore
+ newpath 433 352 moveto
+ 501 352 lineto
+ stroke
+ gsave 10 dict begin
+ 467 337 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8ea0 -> Node0x100bb8f00
+ newpath 470 408 moveto
+ 469 401 469 392 469 382 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 471 382 moveto
+ 468 372 lineto
+ 467 382 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8d80
+ gsave 10 dict begin
+ newpath 428 484 moveto
+ 513 484 lineto
+ 513 524 lineto
+ 428 524 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 470 509 moveto 71 -0.5 (sethi \(n24\)) alignedtext
+ end grestore
+ newpath 428 504 moveto
+ 513 504 lineto
+ stroke
+ gsave 10 dict begin
+ 470 489 moveto 49 -0.5 (True[0]) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100bb8d80 -> Node0x100bb8ea0
+ newpath 470 484 moveto
+ 470 478 470 468 470 459 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 473 458 moveto
+ 470 448 lineto
+ 468 458 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100bb8f00 -> Node0x100bb8f60
+ newpath 467 332 moveto
+ 467 325 467 316 467 306 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 469 306 moveto
+ 466 296 lineto
+ 465 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ endpage
+ grestore
+ %%PageTrailer
+ %%EndPage: 1
+ %%Trailer
+ %%Pages: 1
+ end
+ restore
+ %%EOF
+ 
+ %%EndDocument
+ 
+  endTexFig
+  1563 9779 a Fx(Figure)60 b(4.4:)79 b(Dep)5 b(endence)60
+ b(Graph)g(After)h(Dep)5 b(endence)59 b(Analysis)3809
+ 11136 y(29)p eop end
+ %%Page: 30 37
+ TeXDict begin 30 36 bop 1338 297 a Ff(getDep)5 b(endenceInfo)p
+ Fs(\(Instruction)54 b(inst1,)49 b(Instruction)j(inst2,)e(b)t(o)t(ol)h
+ (srcBeforeDest\))1227 480 y(1)196 b(Deps)52 b(=)g(Empt)l(yList)352
+ b(//Empt)l(y)51 b(list)e(of)i(dep)t(endences)1227 662
+ y(2)196 b(if)51 b(\(inst1)f(==)i(inst2\))1227 845 y(3)358
+ b(return)52 b(Deps)658 b(//No)51 b(dep)t(endences)j(to)d(the)h(same)f
+ (no)t(de)h(\(self)e(lo)t(ops\))1227 1028 y(4)196 b(if\()51
+ b(!isLoad\(inst1\))d Fn(jj)j Fs(!isStore\(inst1\))e Fn(jj)h
+ Fs(!isLoad\(inst2\))f Fn(jj)h Fs(!isStore\(inst2\)\))1227
+ 1210 y(5)358 b(return)52 b(Deps)9 b(//Only)52 b(deal)g(with)e(memory)i
+ (instructions)1227 1393 y(6)196 b(if)51 b(\(isLo)t(opIn)l(v)-9
+ b(arian)l(t\(inst1\))49 b(&&)j(isLo)t(opIn)l(v)-9 b(arian)l
+ (t\(inst2\)\))1227 1576 y(7)358 b(aliasResult)50 b(=)h
+ (AA.alias\(inst1,)e(inst2\))1227 1758 y(8)358 b(if)51
+ b(\(aliasResult)e(!=)j(NoAlias\))1227 1941 y(9)520 b(Deps)52
+ b(=)g(createDep\(inst1,)f(inst2,)f(srcBeforeDest,)h(0\))1227
+ 2123 y(10)443 b(return)53 b(Deps)1227 2306 y(11)281 b(else)1227
+ 2489 y(12)443 b(return)53 b(Deps)1227 2671 y(13)119 b(else)1227
+ 2854 y(14)281 b(inst1B)50 b(=)i(base)f(p)t(oin)l(ter)h(of)f(memory)g
+ (reference)i(for)e(inst1)1227 3037 y(15)281 b(inst2B)50
+ b(=)i(base)f(p)t(oin)l(ter)h(of)f(memory)g(reference)i(for)e(inst2)1227
+ 3219 y(16)281 b(aliasResult)50 b(=)h(AA.alias\(inst1B,)d(inst2B\))1227
+ 3402 y(17)281 b(if)51 b(\(aliasResult)e(==)j(MustAlias\))1227
+ 3585 y(18)443 b(advDepAnalysis\(inst1,)50 b(inst2,)g(srcBeforeDest\))
+ 1227 3767 y(19)281 b(else)51 b(if\(aliasResult)e(==)j(Ma)l(yAlias\))
+ 1227 3950 y(20)443 b(Deps)52 b(=)g(createDep\(inst1,)f(inst2,)f
+ (srcBeforeDest,)h(0\))1227 4133 y(21)119 b(return)52
+ b(Deps)1338 4498 y Ff(advDepAnalysis)p Fs(\(Instruction)h(inst1,)d
+ (Instruction)i(inst2,)e(b)t(o)t(ol)h(srcBeforeDest\))1227
+ 4681 y(1)1227 4863 y(2)196 b(if)51 b(\(!isSingleDimensional\(inst1\))d
+ Fn(jj)i Fs(!isSingleDimensional\(inst2\)\))1227 5046
+ y(3)358 b(return)52 b(createDep\(inst1,)g(inst2,)e(srcBeforeDest,)g
+ (0\))1227 5228 y(4)196 b(SCEV1)51 b(=)h(SE.getSCEV\(inst1\))1227
+ 5411 y(5)196 b(SCEV2)51 b(=)h(SE.getSCEV\(inst2\))1227
+ 5594 y(6)196 b(if)51 b(\()g(isA\016ne\(SCEV1\))f(&&)i
+ (isA\016ne\(SCEV2\)\))2959 5776 y(//A\016ne)g(means)f(A)g(+)h(B*x)f
+ (form)1227 5959 y(7)358 b(if)51 b(\(SCEV1.B)f(!=)i(SCEV2.B\))1227
+ 6142 y(8)520 b(return)53 b(createDep\(inst1,)e(inst2,)f(srcBeforeDest,)
+ h(0\))1227 6324 y(9)358 b(if)51 b(\(SCEV1.A)g(==)h(SCEV2.A\))1227
+ 6507 y(10)443 b(return)53 b(createDep\(inst1,)e(inst2,)f
+ (srcBeforeDest,)h(0\))1227 6690 y(11)281 b(dist)51 b(=)h(SCEV1.A)e(-)i
+ (SCEV2.A)1227 6872 y(12)281 b(if)51 b(\(dist)f Fm(>)i
+ Fs(0\))1227 7055 y(13)443 b(return)53 b(createDep\(inst1,)e(inst2,)f
+ (srcBeforeDest,)h(dist\))1338 7420 y Ff(createDep)p Fs(\(Instruction)h
+ (inst1,)e(Instruction)h(inst2,)f(b)t(o)t(ol)h(srcBeforeDest,)g(in)l(t)g
+ (dist\))1227 7603 y(1)196 b(if)51 b(\(!srcBeforeDest)g(&&)h(dist==0\))
+ 1227 7786 y(2)358 b(dist)51 b(=)h(1)1227 7968 y(3)196
+ b(if)51 b(\(isLoad\(inst1\))e(&&)j(isStore\(inst2\)\)\))1227
+ 8151 y(4)358 b(if\(srcBeforeDest\))1227 8333 y(5)520
+ b(return)53 b(An)l(ti-Dep)t(endence)h(with)d(a)g(distance)g(of)g
+ Fm(dist)1227 8516 y Fs(6)358 b(else)1227 8699 y(7)520
+ b(return)53 b(T)-13 b(rue-Dep)t(endence)55 b(with)c(a)g(distance)g(of)g
+ Fm(dist)1227 8881 y Fs(8)196 b(else)51 b(if)g(\(isStore\(inst1\))e(&&)j
+ (isLoad\(inst2\)\))1227 9064 y(9)358 b(if\(srcBeforeDest\))1227
+ 9247 y(10)443 b(return)53 b(T)-13 b(rue-Dep)t(endence)55
+ b(with)c(a)g(distance)g(of)g Fm(dist)1227 9429 y Fs(11)281
+ b(else)1227 9612 y(12)443 b(return)53 b(An)l(ti-Dep)t(endence)h(with)d
+ (a)g(distance)g(of)g Fm(dist)1227 9795 y Fs(13)119 b(else)51
+ b(if)g(\(isStore\(inst1\))e(&&)j(isStore\(inst2\)\))1227
+ 9977 y(14)281 b(return)52 b(Output-Dep)t(endence)k(with)51
+ b(a)g(distance)g(of)g Fm(dist)1882 10497 y Fx(Figure)60
+ b(4.5:)80 b(Pseudo)59 b(Co)5 b(de)61 b(for)f(Dep)5 b(endence)60
+ b(Analyzer)3809 11136 y(30)p eop end
+ %%Page: 31 38
+ TeXDict begin 31 37 bop 282 183 a Fx(Figure)68 b(4.5)f(sho)-5
+ b(ws)68 b(the)g(algorithm)f(used)h(b)-5 b(y)68 b(our)h(dep)5
+ b(endence)67 b(analyzer.)103 b(The)68 b Fj(getDep)6 b(endenceInfo)0
+ 548 y Fx(function)81 b(tak)-5 b(es)81 b(t)-5 b(w)g(o)82
+ b(instructions)e(and)i(a)g(b)5 b(o)g(olean)81 b(that)h(indicates)e(if)h
+ (the)h(\014rst)f(instruction)g(is)g(executed)0 913 y(b)5
+ b(efore)52 b(the)g(second)g(and)g(returns)h(the)f(list)f(of)h(dep)5
+ b(endences)51 b(b)5 b(et)-5 b(w)g(een)52 b(them.)77 b(If)52
+ b(the)g(t)-5 b(w)g(o)53 b(instructions)d(are)i(the)0
+ 1279 y(same,)69 b(there)f(is)f(no)i(dep)5 b(endence)67
+ b(b)5 b(ecause)68 b(an)g(instruction)e(only)i(o)5 b(ccurs)68
+ b(once)g(in)g(the)g(\014nal)g(lo)5 b(op.)103 b(The)68
+ b(t)-5 b(w)g(o)0 1644 y(instructions)58 b(are)j(then)f(c)-5
+ b(hec)g(k)g(ed)60 b(to)g(ensure)g(that)g(they)g(are)h(b)5
+ b(oth)60 b(memory)g(op)5 b(erations)59 b(\(load)h(or)g(a)h(store\).)282
+ 2010 y(Once)79 b(the)f(dep)5 b(endence)78 b(analyzer)f(is)h(con\014den)
+ -5 b(t)78 b(that)g(t)-5 b(w)g(o)78 b(memory)g(op)5 b(erations)77
+ b(are)i(b)5 b(eing)78 b(analyzed,)0 2375 y(it)86 b(examines)f(eac)-5
+ b(h)86 b(memory)g(reference)g(and)g(determines)f(if)h(the)g(memory)g
+ (addresses)g(accessed)f(are)i(lo)5 b(op)0 2740 y(in)-5
+ b(v)-10 b(arian)-5 b(t.)91 b(If)63 b(the)i(addresses)e(are)i(lo)5
+ b(op)63 b(in)-5 b(v)-10 b(arian)-5 b(t,)64 b(then)g(Alias)g(Analysis)f
+ (alone)h(can)g(b)5 b(e)64 b(used)g(to)h(determine)0 3106
+ y(if)78 b(there)g(is)g(a)g(dep)5 b(endence)78 b(b)5 b(et)-5
+ b(w)g(een)78 b(them.)133 b(If)78 b(the)g(t)-5 b(w)g(o)79
+ b(addresses)e(are)i(not)f(lo)5 b(op)78 b(in)-5 b(v)-10
+ b(arian)-5 b(t,)81 b(then)d(Alias)0 3471 y(Analysis)67
+ b(is)g(used)h(to)g(compare)g(the)g(base)f(p)5 b(oin)-5
+ b(ters)67 b(for)h(eac)-5 b(h)68 b(memory)f(reference.)103
+ b(If)67 b(AA)i(can)f(pro)-5 b(v)g(e)68 b(there)0 3836
+ y(is)77 b(a)h(No-Alias)f(relation,)j(then)e(no)g(dep)5
+ b(endence)77 b(is)g(created.)132 b(If)77 b(AA)i(can)f(only)f(pro)-5
+ b(v)g(e)78 b(that)f(the)h(t)-5 b(w)g(o)78 b(base)0 4202
+ y(p)5 b(oin)-5 b(ters)62 b(Ma)-5 b(y-Alias,)62 b(then)g(a)i(dep)5
+ b(endence)62 b(is)g(created.)88 b(Lastly)-15 b(,)61 b(if)i(AA)h(can)f
+ (pro)-5 b(v)g(e)63 b(that)f(the)h(t)-5 b(w)g(o)63 b(addresses)0
+ 4567 y(Must-Alias,)58 b(then)i(further)g(dep)5 b(endence)60
+ b(analysis)f(is)g(need.)282 4933 y(The)g Fj(createDep)f
+ Fx(pro)5 b(cedure)58 b(creates)f(the)g(dep)5 b(endence)58
+ b(b)5 b(et)-5 b(w)g(een)57 b(the)h(t)-5 b(w)g(o)58 b(instructions.)77
+ b(The)59 b(distance)0 5298 y(of)47 b(the)g(dep)5 b(endence)46
+ b(is)g(almost)g(alw)-5 b(a)g(ys)46 b(determined)g(b)-5
+ b(y)47 b(the)g(callee.)74 b(Ho)-5 b(w)g(ev)g(er,)50 b(if)c(the)h
+ (\014rst)g(instruction)e(o)5 b(ccurs)0 5663 y(after)63
+ b(the)h(second)g(\(in)f(execution)g(order\),)i(and)f(the)g(distance)f
+ (has)h(defaulted)e(to)i(zero)g(\(this)f(means)g(the)h(true)0
+ 6029 y(distance)49 b(could)h(not)g(b)5 b(e)50 b(found\),)h(the)f
+ (distance)f(is)h(set)f(to)h(one.)77 b(This)50 b(means)f(that)h(a)g
+ (conserv)-10 b(ativ)-5 b(e)49 b(assumption)0 6394 y(is)60
+ b(tak)-5 b(en)60 b(that)g(the)g(instructions)e(ha)-5
+ b(v)g(e)60 b(a)h(dep)5 b(endence)60 b(across)g(one)g(iteration.)282
+ 6759 y(If)53 b(further)h(analysis)e(is)h(needed,)h(the)f
+ Fj(advDepAnalysis)j Fx(function)c(is)h(called.)76 b(It)54
+ b(b)5 b(egins)52 b(b)-5 b(y)54 b(determining)0 7125 y(if)86
+ b(the)g(memory)g(access)f(is)h(to)g(a)h(single)e(dimensional)f(arra)-5
+ b(y)-15 b(.)159 b(Our)87 b(dep)5 b(endence)86 b(analyzer)g(only)g
+ (handles)0 7490 y(single)e(dimensional)e(arra)-5 b(ys)86
+ b(\(as)e(they)h(are)g(most)f(common\),)90 b(but)85 b(there)f(is)h
+ (nothing)f(prev)-5 b(en)g(ting)84 b(it)h(from)0 7856
+ y(b)5 b(eing)64 b(extended)f(to)h(handle)g(m)-5 b(ulti)62
+ b(dimensional)g(arra)-5 b(ys.)91 b(Using)64 b(Scalar)g(Ev)-5
+ b(olution)62 b(analysis,)h(the)h(memory)0 8221 y(reference)54
+ b(is)h(transformed)f(in)-5 b(to)54 b(a)i(uniform)e(represen)-5
+ b(tation:)76 b Fq(A)p Fx(+)56 b Fq(B)39 b Fr(\003)30
+ b Fq(x)p Fx(,)56 b(where)f(A)h(is)e(the)h(o\013set,)g(and)h(B*x)f(is)0
+ 8586 y(some)d(constan)-5 b(t)53 b(times)e(the)i(base)g(p)5
+ b(oin)-5 b(ter.)77 b(Our)55 b(dep)5 b(endence)52 b(analyzer)h(has)g
+ (already)g(used)g(Alias)f(Analysis)g(to)0 8952 y(determine)j(the)h
+ (relationship)e(b)5 b(et)-5 b(w)g(een)56 b(base)g(p)5
+ b(oin)-5 b(ters)56 b(\(Must-Alias\).)76 b(The)56 b(B)h(v)-10
+ b(alues)55 b(are)h(compared,)g(and)h(if)0 9317 y(they)63
+ b(are)h(not)g(equal)f(a)h(dep)5 b(endence)63 b(is)g(created)g(b)5
+ b(et)-5 b(w)g(een)64 b(the)f(instructions.)88 b(Lastly)-15
+ b(,)63 b(the)g(o\013sets)g(\(A)h(v)-10 b(alue\))0 9682
+ y(are)63 b(compared.)88 b(If)63 b(they)g(are)g(equal,)g(the)g(same)f
+ (elemen)-5 b(t)61 b(is)i(b)5 b(eing)63 b(accessed)f(and)h(a)g(dep)5
+ b(endence)63 b(is)f(created.)0 10048 y(If)d(they)g(are)g(not)h(equal,)e
+ (the)h(di\013erence)g(b)5 b(et)-5 b(w)g(een)59 b(the)g(t)-5
+ b(w)g(o)59 b(v)-10 b(alues)59 b(is)f(the)h(distance)g(of)g(the)g(dep)5
+ b(endence,)58 b(and)0 10413 y(a)j(dep)5 b(endence)59
+ b(is)h(created.)3809 11136 y(31)p eop end
+ %%Page: 32 39
+ TeXDict begin 32 38 bop 0 183 a Ft(4.3)270 b(Calculating)89
+ b(the)g(Minim)-7 b(um)90 b(Initiation)g(In)-7 b(terv)-15
+ b(al)0 728 y Fx(The)77 b(Minim)-5 b(um)74 b(Initiation)h(In)-5
+ b(terv)-10 b(al)75 b(\(MI)5 b(I\))75 b(is)h(the)g(minim)-5
+ b(um)75 b(n)-5 b(um)g(b)5 b(er)76 b(of)g(cycles)g(b)5
+ b(et)-5 b(w)g(een)76 b(initiations)e(of)0 1093 y(t)-5
+ b(w)g(o)86 b(iterations)f(of)h(the)g(lo)5 b(op.)157 b(The)87
+ b(v)-10 b(alue)86 b(is)f(constrained)g(b)-5 b(y)87 b(resources)f(or)g
+ (dep)5 b(endences)86 b(in)g(the)g(Data)0 1459 y(Dep)5
+ b(endence)64 b(Graph.)93 b(If)64 b(there)h(are)g(not)f(enough)h
+ (resources)f(a)-5 b(v)-10 b(ailable,)64 b(instructions)e(will)i(b)5
+ b(e)65 b(dela)-5 b(y)g(ed)64 b(from)0 1824 y(issuing)71
+ b(un)-5 b(til)71 b(the)h(needed)g(resources)g(are)g(free.)116
+ b(If)72 b(there)g(are)g(dep)5 b(endence)72 b(constrain)-5
+ b(ts,)73 b(instructions)d(can)0 2190 y(not)f(complete)f(un)-5
+ b(til)69 b(all)g(its)g(op)5 b(erand)69 b(v)-10 b(alues)69
+ b(are)h(a)-5 b(v)-10 b(ailable.)106 b(SMS)69 b(uses)g(the)h(MI)5
+ b(I)69 b(as)g(a)h(starting)e(v)-10 b(alue)69 b(for)0
+ 2555 y(I)5 b(I)72 b(when)h(generating)f(a)g(sc)-5 b(hedule,)74
+ b(whic)-5 b(h)73 b(is)f(the)g(lo)-5 b(w)g(est)72 b(v)-10
+ b(alue)72 b(that)g(can)h(b)5 b(e)72 b(ac)-5 b(hiev)g(e)72
+ b(giv)-5 b(en)72 b(resource)g(and)0 2920 y(dep)5 b(endence)60
+ b(constrain)-5 b(ts.)0 3551 y Fk(4.3.1)225 b(Resource)75
+ b(I)6 b(I)0 4034 y Fx(The)63 b(Resource)f(Minim)-5 b(um)61
+ b(Initiation)g(In)-5 b(terv)-10 b(al)61 b(\(ResMI)5 b(I\))61
+ b(is)h(calculated)f(b)-5 b(y)63 b(summing)f(the)g(resource)h(usage)0
+ 4399 y(requiremen)-5 b(ts)68 b(for)h(one)g(iteration)f(of)h(the)g(lo)5
+ b(op.)106 b(A)70 b(reserv)-10 b(ation)68 b(table)h([33)o(])g(represen)
+ -5 b(ts)69 b(the)g(resource)g(usage)0 4764 y(patterns)42
+ b(for)i(eac)-5 b(h)42 b(cycle)h(during)g(one)g(iteration)e(of)i(a)h(lo)
+ 5 b(op.)74 b(By)43 b(p)5 b(erforming)42 b(a)h(bin-pac)-5
+ b(king)42 b(of)g(the)h(reserv)-10 b(ation)0 5130 y(table)57
+ b(for)g(all)g(instructions,)e(the)i(exact)g(ResMI)5 b(I)56
+ b(is)h(found.)79 b(Ho)-5 b(w)g(ev)g(er,)58 b(this)f(pro)5
+ b(cess)56 b(can)i(b)5 b(e)57 b(time)g(consuming)0 5495
+ y(\(bin-pac)-5 b(king)59 b(is)g(an)i(NP)g(complete)d(problem\),)h(so)h
+ (an)h(appro)-5 b(ximation)58 b(for)j(ResMI)5 b(I)59 b(is)h(computed.)
+ 282 5861 y(T)-15 b(o)55 b(calculate)e(an)i(appro)-5 b(ximation)52
+ b(for)j(ResMI)5 b(I,)53 b(eac)-5 b(h)54 b(instruction)f(is)h(examined)f
+ (for)h(its)g(resource)g(usages.)0 6226 y(The)86 b(most)f(hea)-5
+ b(vily)84 b(used)h(resource)h(sets)e(the)i(ResMI)5 b(I.)83
+ b(Figure)i(4.2)g(sho)-5 b(ws)86 b(all)e(the)i(instructions)d(for)j(our)
+ 0 6591 y(example)66 b(lo)5 b(op.)102 b(Examining)66 b(these)h
+ (instructions)e(will)i(sho)-5 b(w)68 b(that)f(the)g(most)g(hea)-5
+ b(vily)67 b(used)g(resource)g(is)g(the)0 6957 y(in)-5
+ b(teger)62 b(unit.)86 b(A)64 b(total)e(of)g(33)h(instructions)e(use)h
+ (this)g(resource,)g(and)h(there)g(are)g(2)g(in)-5 b(teger)61
+ b(units,)h(whic)-5 b(h)63 b(sets)0 7322 y(the)d(ResMI)5
+ b(I)59 b(for)h(this)g(lo)5 b(op)60 b(at)g(17.)0 7953
+ y Fk(4.3.2)225 b(Recurrence)73 b(I)6 b(I)0 8435 y Fx(Recurrences)74
+ b(ma)-5 b(y)74 b(b)5 b(e)74 b(found)g(in)g(the)g(the)g(DDG)g(if)g
+ (instructions)e(ha)-5 b(v)g(e)75 b(dep)5 b(endences)73
+ b(across)h(iterations)f(of)0 8801 y(the)68 b(lo)5 b(op.)105
+ b(Memory)68 b(op)5 b(erations)67 b(\(load/store\))g(are)i(most)e(lik)-5
+ b(ely)67 b(the)i(cause)f(of)g(a)h(recurrence)f(in)h(the)f(DDG.)0
+ 9166 y(Recurrences)60 b(are)g(also)g(kno)-5 b(wn)61 b(as)f(circuits)f
+ (or)h(cycles.)282 9532 y(In)88 b(order)g(to)f(compute)g(the)h
+ (Recurrence)f(Minim)-5 b(um)86 b(Initiation)f(In)-5 b(terv)-10
+ b(al)86 b(\(RecMI)5 b(I\),)86 b(all)h(recurrences)0 9897
+ y(in)74 b(the)g(DDG)g(m)-5 b(ust)74 b(b)5 b(e)74 b(found.)122
+ b(In)74 b(our)h(implemen)-5 b(tation)71 b(of)j(SMS,)f(the)h(algorithm)f
+ (prop)5 b(osed)74 b(b)-5 b(y)75 b(Donald)0 10262 y(Johnson)69
+ b([23)o(])f(is)g(used)h(to)f(\014nd)h(all)f(elemen)-5
+ b(tary)67 b(circuits)g(in)h(the)h(DDG.)e(If)h(no)h(v)-5
+ b(ertex)68 b(except)g(the)h(\014rst)f(and)0 10628 y(last)f(app)5
+ b(ear)69 b(t)-5 b(wice,)69 b(then)g(a)f(circuit)f(is)h(termed)g(elemen)
+ -5 b(tary)-15 b(.)102 b(Johnson's)68 b(algorithm)f(is)h(extremely)f
+ (e\016cien)-5 b(t)3809 11136 y(32)p eop end
+ %%Page: 33 40
+ TeXDict begin 33 39 bop 1420 1393 a Ff(\014ndAllCircuits)p
+ Fs(\(DDG)51 b Fm(G)p Fs(\))1309 1576 y(1)196 b(empt)l(y)51
+ b Fm(stack)1309 1758 y Fs(2)196 b Fm(s)42 b Fs(=)52 b(1)1309
+ 1941 y(3)196 b(while)51 b(\()p Fm(s)42 b(<)51 b(n)p Fs(\))1309
+ 2123 y(4)358 b Fm(Ak)47 b Fs(=)52 b Fn(f)f Fs(Adjacency)h(structure)g
+ (of)f(a)g(strong)f(comp)t(onen)l(t)i(K)g(with)f(least)f(v)l(ertex)1906
+ 2306 y(in)h(subgraph)h(of)f(G)g(induced)h(b)l(y)g Fn(f)p
+ Fm(s)p Fs(,)e Fm(s)p Fs(+)h(1,)g(...,)f Fm(n)p Fn(g)g(g)1309
+ 2489 y Fs(5)358 b(if)51 b(\()p Fm(Ak)c Fn(6)p Fs(=)k
+ Fn(;)p Fs(\))1309 2671 y(6)520 b Fm(s)42 b Fs(=)52 b
+ Fn(f)p Fs(Least)e(v)l(ertex)i(in)f Fm(Ak)t Fn(g)1309
+ 2854 y Fs(7)520 b Fn(8)52 b Fm(i)e Fn(2)i Fm(Ak)1309
+ 3037 y Fs(8)682 b Fm(bl)r(ock)t(ed)p Fs(\()p Fm(i)p Fs(\))43
+ b(=)52 b(false)1309 3219 y(9)682 b Fm(B)7 b Fs(\()p Fm(i)p
+ Fs(\))42 b(=)52 b Fn(;)1309 3402 y Fs(10)443 b Ff(circuit)p
+ Fs(\()p Fm(s)p Fs(\))1309 3585 y(11)g Fm(s)42 b Fs(=)52
+ b Fm(s)p Fs(+)f(1)1309 3767 y(12)281 b(else)1309 3950
+ y(13)443 b Fm(s)42 b Fs(=)52 b Fm(n)1420 4315 y Ff(circuit)p
+ Fs(\(in)l(t)d Fm(v)5 b Fs(\))1309 4498 y(1)196 b Fm(f)58
+ b Fs(=)52 b(false)1309 4681 y(2)196 b(stac)l(k)50 b Fm(v)1309
+ 4863 y Fs(3)196 b Fm(bl)r(ock)t(ed)p Fs(\()p Fm(v)5 b
+ Fs(\))43 b(=)52 b(true)1309 5046 y(4)196 b Fn(8)p Fm(w)55
+ b Fn(2)d Fm(Ak)t Fs(\()p Fm(v)5 b Fs(\))1309 5228 y(5)358
+ b(if\()p Fm(w)46 b Fs(=)52 b Fm(s)p Fs(\))1309 5411 y(6)520
+ b(output)51 b(circuit)h(comp)t(osed)f(of)g(stac)l(k)g(follo)l(w)l(ed)f
+ (b)l(y)h(s)1309 5594 y(7)520 b Fm(f)58 b Fs(=)52 b(true)1309
+ 5776 y(8)358 b(else)51 b(if)g(\()p Fn(:)p Fm(bl)r(ock)t(ed)p
+ Fs(\()p Fm(w)t Fs(\)\))1309 5959 y(9)520 b(if)51 b(\(circuit\()p
+ Fm(w)t Fs(\)\))1309 6142 y(10)605 b Fm(f)59 b Fs(=)51
+ b(true)1309 6324 y(11)119 b(if)51 b(\()p Fm(f)16 b Fs(\))1309
+ 6507 y(12)281 b Ff(un)-5 b(blo)5 b(c)-5 b(k)p Fs(\()p
+ Fm(v)5 b Fs(\))1309 6690 y(13)119 b(else)1309 6872 y(14)281
+ b Fn(8)p Fm(w)55 b Fn(2)d Fm(Ak)1309 7055 y Fs(15)443
+ b(if)51 b(\()p Fm(v)56 b Fn(3)51 b Fm(B)7 b Fs(\()p Fm(w)t
+ Fs(\)\))1309 7238 y(16)605 b(put)52 b Fm(v)k Fs(on)51
+ b Fm(B)7 b Fs(\()p Fm(w)t Fs(\))1309 7420 y(17)119 b(unstac)l(k)51
+ b(v)1309 7603 y(18)119 b(return)52 b Fm(f)1420 7968 y
+ Ff(un)-5 b(blo)5 b(c)-5 b(k)p Fs(\(in)l(t)51 b Fm(u)p
+ Fs(\))1309 8151 y(1)196 b Fm(bl)r(ock)t(ed)p Fs(\()p
+ Fm(u)p Fs(\))44 b(=)51 b(false)1309 8333 y(2)196 b Fn(8)p
+ Fm(w)55 b Fn(2)d Fm(B)7 b Fs(\()p Fm(u)p Fs(\))1309 8516
+ y(3)358 b(delete)52 b Fm(w)j Fs(from)c Fm(B)7 b Fs(\()p
+ Fm(u)p Fs(\))1309 8699 y(4)358 b(if)51 b(\()p Fm(bl)r(ock)t(ed)p
+ Fs(\()p Fm(w)t Fs(\)\))1309 8881 y(5)520 b Ff(un)-5 b(blo)5
+ b(c)-5 b(k)p Fs(\()p Fm(w)t Fs(\))1690 9401 y Fx(Figure)60
+ b(4.6:)80 b(Pseudo)59 b(Co)5 b(de)61 b(for)f(Circuit)g(Finding)f
+ (Algorithm)3809 11136 y(33)p eop end
+ %%Page: 34 41
+ TeXDict begin 34 40 bop 0 183 a Fx(\(compared)88 b(to)g(all)g(other)h
+ (existing)e(circuit)g(\014nding)h(algorithms\))f(and)i(\014nds)f(all)g
+ (circuits)f(in)i(a)g(graph)f(in)0 548 y Fq(O)5 b Fx(\(\()p
+ Fq(n)40 b Fx(+)i Fq(e)p Fx(\)\()p Fq(c)d Fx(+)j(1\)\),)60
+ b(where)i(c)f(is)g(the)g(total)f(n)-5 b(um)g(b)5 b(er)61
+ b(of)g(circuits,)e(n)j(is)e(the)h(total)g(n)-5 b(um)g(b)5
+ b(er)61 b(of)f(no)5 b(des,)61 b(and)h(e)f(is)0 913 y(the)f(total)f(n)-5
+ b(um)g(b)5 b(er)61 b(of)f(edges)g(in)g(the)g(DDG.)282
+ 1279 y(Figure)73 b(4.6)h(sho)-5 b(ws)73 b(Johnson's)g(circuit)g
+ (\014nding)g(algorithm.)118 b(It)74 b(b)5 b(egins,)75
+ b(b)-5 b(y)74 b(ordering)g(all)f(the)g(no)5 b(des)73
+ b(in)0 1644 y(the)g(graph.)121 b(It)73 b(\014nds)h(the)f(Strongly)g
+ (Connected)h(Comp)5 b(onen)-5 b(t)4517 1578 y Fo(3)4669
+ 1644 y Fx(\(SCC\))74 b(with)f(the)h(least)e(v)-5 b(ertex,)76
+ b(and)e(\014nds)0 2010 y(all)56 b(recurrences)h(within)g(this)f(SCC.)h
+ (Recurrences)g(are)g(built)f(b)-5 b(y)58 b(building)e(elemen)-5
+ b(tary)55 b(paths)i(from)f(the)h(least)0 2375 y(v)-5
+ b(ertex.)80 b(The)61 b Fj(circuit\(\))g Fx(pro)5 b(cedure)61
+ b(is)f(resp)5 b(onsible)59 b(for)h(app)5 b(ending)60
+ b(a)g(no)5 b(de)61 b(to)f(the)g(path,)g(determining)e(if)i(a)0
+ 2740 y(recurrence)66 b(is)f(found,)i(and)f(un)-5 b(blo)5
+ b(c)-5 b(king)65 b(the)h(no)5 b(de)66 b(once)g(it)f(exits.)96
+ b(No)5 b(des)66 b(are)g Fu(blo)5 b(c)-5 b(k)g(ed)65 b
+ Fx(whenev)-5 b(er)66 b(they)g(are)0 3106 y(added)k(to)h(the)f(path)g
+ (in)g(order)h(to)f(guaran)-5 b(tee)70 b(that)g(a)g(no)5
+ b(de)71 b(can)f(nev)-5 b(er)70 b(b)5 b(e)71 b(used)f(t)-5
+ b(wice)70 b(on)g(the)g(same)g(path.)0 3471 y(The)55 b(pro)5
+ b(cess)54 b(of)g(un)-5 b(blo)5 b(c)-5 b(king)53 b(a)i(no)5
+ b(de)54 b(is)g(dela)-5 b(y)g(ed)53 b(as)i(long)f(as)g(p)5
+ b(ossible,)54 b(usually)f(un)-5 b(til)53 b(a)i(recurrence)f(is)g
+ (found.)0 3836 y(It)60 b(rep)5 b(eats)60 b(the)g(pro)5
+ b(cess)60 b(for)g(eac)-5 b(h)60 b(SCC)h(in)g(the)f(graph,)g(in)g(the)g
+ (order)h(set)f(b)-5 b(y)60 b(ho)-5 b(w)61 b(the)f(no)5
+ b(des)60 b(are)h(ordered.)p 2176 4078 3397 7 v 2173 4260
+ 7 183 v 2276 4206 a Fs(No)t(de)p 3098 4260 V 576 w(Latency)p
+ 3833 4260 V 3866 4260 V 233 w(No)t(de)p 4834 4260 V 619
+ w(Latency)p 5569 4260 V 2176 4267 3397 7 v 2173 4450
+ 7 183 v 2276 4395 a(sethi)51 b(\(n1\))p 3098 4450 V 734
+ w(1)p 3833 4450 V 3866 4450 V 232 w(or)g(\(n17\))p 4834
+ 4450 V 880 w(1)p 5569 4450 V 2173 4632 V 2276 4577 a(sethi)g(\(n2\))p
+ 3098 4632 V 734 w(1)p 3833 4632 V 3866 4632 V 232 w(sll)f(\(n18\))p
+ 4834 4632 V 871 w(1)p 5569 4632 V 2173 4815 V 2276 4760
+ a(sethi)h(\(n4\))p 3098 4815 V 734 w(1)p 3833 4815 V
+ 3866 4815 V 232 w(or)g(\(n19\))p 4834 4815 V 880 w(1)p
+ 5569 4815 V 2173 4998 V 2276 4943 a(or)g(\(n5\))p 3098
+ 4998 V 914 w(1)p 3833 4998 V 3866 4998 V 232 w(or)g(\(n20\))p
+ 4834 4998 V 880 w(1)p 5569 4998 V 2173 5180 V 2276 5125
+ a(sethi)g(\(n6\))p 3098 5180 V 734 w(1)p 3833 5180 V
+ 3866 5180 V 232 w(add)h(\(n21\))p 4834 5180 V 769 w(1)p
+ 5569 5180 V 2173 5363 V 2276 5308 a(or)f(\(n7\))p 3098
+ 5363 V 914 w(1)p 3833 5363 V 3866 5363 V 232 w(ld)h(\(n22\))p
+ 4834 5363 V 888 w(3)p 5569 5363 V 2173 5545 V 2276 5491
+ a(or)f(\(n8\))p 3098 5545 V 914 w(1)p 3833 5545 V 3866
+ 5545 V 232 w(sllx)f(\(n23\))p 4834 5545 V 790 w(1)p 5569
+ 5545 V 2173 5728 V 2276 5673 a(add)i(\(n9\))p 3098 5728
+ V 803 w(1)p 3833 5728 V 3866 5728 V 232 w(sethi)f(\(n24\))p
+ 4834 5728 V 700 w(1)p 5569 5728 V 2173 5911 V 2276 5856
+ a(sethi)g(\(n10\))p 3098 5911 V 657 w(1)p 3833 5911 V
+ 3866 5911 V 232 w(ld)h(\(n25\))p 4834 5911 V 888 w(3)p
+ 5569 5911 V 2173 6093 V 2276 6039 a(sllx)e(\(n11\))p
+ 3098 6093 V 747 w(1)p 3833 6093 V 3866 6093 V 232 w(sll)g(\(n26\))p
+ 4834 6093 V 871 w(1)p 5569 6093 V 2173 6276 V 2276 6221
+ a(sllx)g(\(n12\))p 3098 6276 V 747 w(1)p 3833 6276 V
+ 3866 6276 V 232 w(or)h(\(n27\))p 4834 6276 V 880 w(3)p
+ 5569 6276 V 2173 6459 V 2276 6404 a(or)g(\(n13\))p 3098
+ 6459 V 837 w(1)p 3833 6459 V 3866 6459 V 232 w(or)g(\(n29\))p
+ 4834 6459 V 880 w(1)p 5569 6459 V 2173 6641 V 2276 6587
+ a(sethi)g(\(n14\))p 3098 6641 V 657 w(1)p 3833 6641 V
+ 3866 6641 V 232 w(add)h(\(n32\))p 4834 6641 V 769 w(1)p
+ 5569 6641 V 2173 6824 V 2276 6769 a(or)f(\(n15\))p 3098
+ 6824 V 837 w(1)p 3833 6824 V 3866 6824 V 232 w(fm)l(uls)g(\(n34\))p
+ 4834 6824 V 657 w(4)p 5569 6824 V 2173 7007 V 2276 6952
+ a(srl)f(\(n16\))p 3098 7007 V 811 w(1)p 3833 7007 V 3866
+ 7007 V 232 w(st)h(\(n35\))p 4834 7007 V 896 w(0)p 5569
+ 7007 V 2176 7013 3397 7 v 1815 7405 a Fx(T)-15 b(able)60
+ b(4.1:)79 b(No)5 b(de)61 b(Latencies)e(for)h(Simple)f(Lo)5
+ b(op)60 b(Example)282 7970 y(Eac)-5 b(h)80 b(recurrence)h(in)f(the)g
+ (graph)h(imp)5 b(oses)78 b(a)j(constrain)-5 b(t)79 b(on)i(the)f(in)-5
+ b(terv)-10 b(al)79 b(b)5 b(et)-5 b(w)g(een)80 b(eac)-5
+ b(h)80 b(instruction)0 8335 y(in)j(this)f(recurrence)i(and)f(the)g
+ (same)g(instruction,)j(Distance\(c\))81 b(iterations)h(later.)148
+ b(This)83 b(constrain)-5 b(t)82 b(m)-5 b(ust)0 8701 y(b)5
+ b(e)79 b(at)f(least)g(the)g(total)g(latency)g(of)g(the)h(recurrence,)j
+ (Latency\(c\).)134 b(Ho)-5 b(w)g(ev)g(er,)83 b(the)78
+ b(distance)g(is)g(really)g Fq(I)14 b(I)g Fr(\003)0 9066
+ y Fq(D)5 b(istance)p Fx(\()p Fq(c)p Fx(\),)42 b(whic)-5
+ b(h)40 b(means)f(the)h(constrain)-5 b(t)39 b(is)h(de\014ned)g(as)g
+ (follo)-5 b(ws)38 b([33]:)69 b Fq(R)q(ecM)20 b(I)14 b(I)65
+ b Fx(=)41 b Fq(Latency)7 b Fx(\()p Fq(c)p Fx(\))p Fq(=)38
+ b(D)5 b(istance)p Fx(\()p Fq(c)p Fx(\).)0 9431 y(T)-15
+ b(able)60 b(4.1)g(sho)-5 b(ws)60 b(the)g(latencies)f(for)h(all)f(the)i
+ (no)5 b(des)60 b(in)g(the)g(dep)5 b(endence)60 b(graph.)282
+ 9797 y(Using)f(the)g(Data)g(Dep)5 b(endence)58 b(Graph)i(in)f(Figure)f
+ (4.4,)h(the)g(circuit)f(\014nding)g(algorithm)g(\014nds)h(one)g(recur-)
+ 0 10162 y(rence)68 b(consisting)e(of)h(the)h(follo)-5
+ b(wing)66 b(no)5 b(des:)95 b(ld)68 b(\(n25\),)h(fm)-5
+ b(uls)66 b(\(n34\),)j(and)f(st)g(\(n35\).)102 b(The)69
+ b(total)e(latency)g(of)p 0 10330 3120 7 v 207 10438 a
+ Fl(3)276 10501 y Fs(A)52 b(strongly)e(connected)j(comp)t(onen)l(t)f(is)
+ e(a)h(comp)t(onen)l(t)h(in)g(whic)l(h)f(ev)l(ery)h(v)l(ertex)f(is)g
+ (reac)l(hable)h(from)f(ev)l(ery)g(other)h(v)l(ertex.)3809
+ 11136 y Fx(34)p eop end
+ %%Page: 35 42
+ TeXDict begin 35 41 bop 0 183 a Fx(this)62 b(circuit)f(is)h(7,)g(and)h
+ (the)f(total)g(distance)f(is)h(1.)86 b(Therefore,)62
+ b(the)g(RecMI)5 b(I)62 b(for)g(the)g(lo)5 b(op)62 b(is)g(7.)87
+ b(Because)61 b(this)0 548 y(is)f(smaller)f(than)h(our)h(ResMI)5
+ b(I,)58 b(the)i(ResMI)5 b(I)59 b(is)h(used)g(as)g(the)h(starting)e(I)5
+ b(I)60 b(v)-10 b(alue.)0 1300 y Ft(4.4)270 b(No)7 b(de)91
+ b(Prop)7 b(erties)0 1845 y Fx(After)42 b(the)g(Data)f(Dep)5
+ b(endence)41 b(Graph)h(has)g(b)5 b(een)42 b(constructed,)i(a)e(few)g
+ (no)5 b(de)42 b(prop)5 b(erties)41 b(need)h(to)g(b)5
+ b(e)42 b(calculated)0 2210 y(in)59 b(order)i(to)e(prop)5
+ b(erly)60 b(order)g(and)g(sc)-5 b(hedule)58 b(the)i(instructions.)78
+ b(Because)58 b(a)i(graph)g(ma)-5 b(y)59 b(con)-5 b(tain)59
+ b(cycles,)f(one)0 2576 y(bac)-5 b(k)42 b(edge)g(\(do)5
+ b(esn't)41 b(matter)g(whic)-5 b(h)43 b(one\))e(is)h(ignored)g(for)g
+ (eac)-5 b(h)42 b(recurrence.)74 b(F)-15 b(or)42 b(the)g(follo)-5
+ b(wing)41 b(no)5 b(de)42 b(prop)5 b(ert)-5 b(y)0 2941
+ y(calculations,)52 b Fq(\025)i Fx(is)f(the)h(latency)e(of)h(a)h
+ (instruction,)f Fq(\016)61 b Fx(is)53 b(the)g(distance)g(of)g(the)g
+ (dep)5 b(endence)53 b(edge)h(b)5 b(et)-5 b(w)g(een)53
+ b(t)-5 b(w)g(o)0 3306 y(no)5 b(des,)63 b Fq(P)25 b(r)5
+ b(ed)p Fx(\(\))62 b(is)g(the)h(set)f(of)g(predecessors)g(for)h(a)g(no)5
+ b(de,)63 b Fq(S)10 b(ucc)p Fx(\(\))63 b(is)f(the)h(set)f(of)h
+ (successors)e(for)i(a)g(no)5 b(de,)63 b(and)0 3672 y
+ Fq(M)20 b(I)14 b(I)75 b Fx(is)60 b(minim)-5 b(um)58 b(initiation)g(in)
+ -5 b(terv)-10 b(al)59 b(describ)5 b(ed)60 b(in)g(Section)f(4.3.)p
+ 1468 3865 4813 7 v 1465 4048 7 183 v 1568 3993 a Fs(No)t(de)p
+ 2433 4048 V 2466 4048 V 652 w(ASAP)p 3086 4048 V 200
+ w(ALAP)p 3716 4048 V 199 w(MOB)p 4284 4048 V 199 w(Depth)p
+ 4899 4048 V 200 w(Heigh)l(t)p 5542 4048 V 199 w(Latency)p
+ 6277 4048 V 1468 4054 4813 7 v 1465 4237 7 183 v 1568
+ 4182 a(sethi)51 b(\(n1\))p 2433 4237 V 2466 4237 V 695
+ w(0)p 3086 4237 V 553 w(1)p 3716 4237 V 491 w(1)p 4284
+ 4237 V 538 w(0)p 4899 4237 V 489 w(12)p 5542 4237 V 658
+ w(1)p 6277 4237 V 1465 4419 V 1568 4365 a(sethi)g(\(n2\))p
+ 2433 4419 V 2466 4419 V 695 w(0)p 3086 4419 V 553 w(0)p
+ 3716 4419 V 491 w(0)p 4284 4419 V 538 w(0)p 4899 4419
+ V 489 w(13)p 5542 4419 V 658 w(1)p 6277 4419 V 1465 4602
+ V 1568 4547 a(sethi)g(\(n4\))p 2433 4602 V 2466 4602
+ V 695 w(0)p 3086 4602 V 553 w(1)p 3716 4602 V 491 w(1)p
+ 4284 4602 V 538 w(0)p 4899 4602 V 489 w(12)p 5542 4602
+ V 658 w(1)p 6277 4602 V 1465 4785 V 1568 4730 a(or)g(\(n5\))p
+ 2433 4785 V 2466 4785 V 875 w(1)p 3086 4785 V 553 w(1)p
+ 3716 4785 V 491 w(0)p 4284 4785 V 538 w(1)p 4899 4785
+ V 489 w(12)p 5542 4785 V 658 w(1)p 6277 4785 V 1465 4967
+ V 1568 4913 a(sethi)g(\(n6\))p 2433 4967 V 2466 4967
+ V 695 w(0)p 3086 4967 V 553 w(2)p 3716 4967 V 491 w(2)p
+ 4284 4967 V 538 w(0)p 4899 4967 V 489 w(11)p 5542 4967
+ V 658 w(1)p 6277 4967 V 1465 5150 V 1568 5095 a(or)g(\(n7\))p
+ 2433 5150 V 2466 5150 V 875 w(1)p 3086 5150 V 553 w(2)p
+ 3716 5150 V 491 w(1)p 4284 5150 V 538 w(1)p 4899 5150
+ V 489 w(11)p 5542 5150 V 658 w(1)p 6277 5150 V 1465 5333
+ V 1568 5278 a(or)g(\(n8\))p 2433 5333 V 2466 5333 V 875
+ w(1)p 3086 5333 V 553 w(2)p 3716 5333 V 491 w(1)p 4284
+ 5333 V 538 w(1)p 4899 5333 V 489 w(11)p 5542 5333 V 658
+ w(1)p 6277 5333 V 1465 5515 V 1568 5461 a(add)h(\(n9\))p
+ 2433 5515 V 2466 5515 V 764 w(2)p 3086 5515 V 553 w(3)p
+ 3716 5515 V 491 w(1)p 4284 5515 V 538 w(2)p 4899 5515
+ V 489 w(10)p 5542 5515 V 658 w(1)p 6277 5515 V 1465 5698
+ V 1568 5643 a(sethi)f(\(n10\))p 2433 5698 V 2466 5698
+ V 618 w(0)p 3086 5698 V 553 w(3)p 3716 5698 V 491 w(3)p
+ 4284 5698 V 538 w(0)p 4899 5698 V 489 w(10)p 5542 5698
+ V 658 w(1)p 6277 5698 V 1465 5881 V 1568 5826 a(sllx)f(\(n11\))p
+ 2433 5881 V 2466 5881 V 708 w(2)p 3086 5881 V 553 w(2)p
+ 3716 5881 V 491 w(0)p 4284 5881 V 538 w(2)p 4899 5881
+ V 489 w(11)p 5542 5881 V 658 w(1)p 6277 5881 V 1465 6063
+ V 1568 6009 a(sllx)g(\(n12\))p 2433 6063 V 2466 6063
+ V 708 w(2)p 3086 6063 V 553 w(3)p 3716 6063 V 491 w(1)p
+ 4284 6063 V 538 w(2)p 4899 6063 V 489 w(10)p 5542 6063
+ V 658 w(1)p 6277 6063 V 1465 6246 V 1568 6191 a(or)h(\(n13\))p
+ 2433 6246 V 2466 6246 V 798 w(3)p 3086 6246 V 553 w(4)p
+ 3716 6246 V 491 w(1)p 4284 6246 V 538 w(3)p 4899 6246
+ V 566 w(9)p 5542 6246 V 658 w(1)p 6277 6246 V 1465 6429
+ V 1568 6374 a(sethi)g(\(n14\))p 2433 6429 V 2466 6429
+ V 618 w(0)p 3086 6429 V 553 w(7)p 3716 6429 V 491 w(7)p
+ 4284 6429 V 538 w(0)p 4899 6429 V 566 w(6)p 5542 6429
+ V 658 w(1)p 6277 6429 V 1465 6611 V 1568 6556 a(or)g(\(n15\))p
+ 2433 6611 V 2466 6611 V 798 w(3)p 3086 6611 V 553 w(3)p
+ 3716 6611 V 491 w(0)p 4284 6611 V 538 w(3)p 4899 6611
+ V 489 w(10)p 5542 6611 V 658 w(1)p 6277 6611 V 1465 6794
+ V 1568 6739 a(srl)g(\(n16\))p 2433 6794 V 2466 6794 V
+ 771 w(3)p 3086 6794 V 553 w(4)p 3716 6794 V 491 w(1)p
+ 4284 6794 V 538 w(3)p 4899 6794 V 566 w(9)p 5542 6794
+ V 658 w(1)p 6277 6794 V 1465 6977 V 1568 6922 a(or)g(\(n17\))p
+ 2433 6977 V 2466 6977 V 798 w(4)p 3086 6977 V 553 w(4)p
+ 3716 6977 V 491 w(0)p 4284 6977 V 538 w(4)p 4899 6977
+ V 566 w(9)p 5542 6977 V 658 w(1)p 6277 6977 V 1465 7159
+ V 1568 7104 a(sll)f(\(n18\))p 2433 7159 V 2466 7159 V
+ 789 w(4)p 3086 7159 V 553 w(5)p 3716 7159 V 491 w(1)p
+ 4284 7159 V 538 w(4)p 4899 7159 V 566 w(8)p 5542 7159
+ V 658 w(1)p 6277 7159 V 1465 7342 V 1568 7287 a(or)h(\(n19\))p
+ 2433 7342 V 2466 7342 V 798 w(4)p 3086 7342 V 553 w(5)p
+ 3716 7342 V 491 w(1)p 4284 7342 V 538 w(4)p 4899 7342
+ V 566 w(8)p 5542 7342 V 658 w(1)p 6277 7342 V 1465 7525
+ V 1568 7470 a(or)g(\(n20\))p 2433 7525 V 2466 7525 V
+ 798 w(1)p 3086 7525 V 553 w(8)p 3716 7525 V 491 w(7)p
+ 4284 7525 V 538 w(1)p 4899 7525 V 566 w(5)p 5542 7525
+ V 658 w(1)p 6277 7525 V 1465 7707 V 1568 7652 a(add)h(\(n21\))p
+ 2433 7707 V 2466 7707 V 687 w(5)p 3086 7707 V 553 w(5)p
+ 3716 7707 V 491 w(0)p 4284 7707 V 538 w(5)p 4899 7707
+ V 566 w(8)p 5542 7707 V 658 w(1)p 6277 7707 V 1465 7890
+ V 1568 7835 a(ld)f(\(n22\))p 2433 7890 V 2466 7890 V
+ 807 w(5)p 3086 7890 V 553 w(6)p 3716 7890 V 491 w(1)p
+ 4284 7890 V 538 w(5)p 4899 7890 V 566 w(7)p 5542 7890
+ V 658 w(3)p 6277 7890 V 1465 8072 V 1568 8018 a(sllx)f(\(n23\))p
+ 2433 8072 V 2466 8072 V 708 w(2)p 3086 8072 V 553 w(9)p
+ 3716 8072 V 491 w(7)p 4284 8072 V 538 w(2)p 4899 8072
+ V 566 w(4)p 5542 8072 V 658 w(1)p 6277 8072 V 1465 8255
+ V 1568 8200 a(sethi)h(\(n24\))p 2433 8255 V 2466 8255
+ V 618 w(0)p 3086 8255 V 553 w(9)p 3716 8255 V 491 w(9)p
+ 4284 8255 V 538 w(0)p 4899 8255 V 566 w(4)p 5542 8255
+ V 658 w(1)p 6277 8255 V 1465 8438 V 1568 8383 a(ld)g(\(n25\))p
+ 2433 8438 V 2466 8438 V 807 w(6)p 3086 8438 V 553 w(6)p
+ 3716 8438 V 491 w(0)p 4284 8438 V 538 w(6)p 4899 8438
+ V 566 w(7)p 5542 8438 V 658 w(3)p 6277 8438 V 1465 8620
+ V 1568 8566 a(sll)f(\(n26\))p 2433 8620 V 2466 8620 V
+ 789 w(0)p 3086 8620 V 476 w(12)p 3716 8620 V 414 w(12)p
+ 4284 8620 V 538 w(0)p 4899 8620 V 566 w(1)p 5542 8620
+ V 658 w(1)p 6277 8620 V 1465 8803 V 1568 8748 a(or)h(\(n27\))p
+ 2433 8803 V 2466 8803 V 798 w(3)p 3086 8803 V 476 w(10)p
+ 3716 8803 V 491 w(7)p 4284 8803 V 538 w(3)p 4899 8803
+ V 566 w(3)p 5542 8803 V 658 w(1)p 6277 8803 V 1465 8986
+ V 1568 8931 a(or)g(\(n29\))p 2433 8986 V 2466 8986 V
+ 798 w(4)p 3086 8986 V 476 w(11)p 3716 8986 V 491 w(7)p
+ 4284 8986 V 538 w(4)p 4899 8986 V 566 w(2)p 5542 8986
+ V 658 w(1)p 6277 8986 V 1465 9168 V 1568 9114 a(add)h(\(n32\))p
+ 2433 9168 V 2466 9168 V 687 w(5)p 3086 9168 V 476 w(12)p
+ 3716 9168 V 491 w(7)p 4284 9168 V 538 w(5)p 4899 9168
+ V 566 w(1)p 5542 9168 V 658 w(1)p 6277 9168 V 1465 9351
+ V 1568 9296 a(fm)l(uls)e(\(n34\))p 2433 9351 V 2466 9351
+ V 576 w(9)p 3086 9351 V 553 w(9)p 3716 9351 V 491 w(0)p
+ 4284 9351 V 538 w(9)p 4899 9351 V 566 w(4)p 5542 9351
+ V 658 w(4)p 6277 9351 V 1465 9534 V 1568 9479 a(st)h(\(n35\))p
+ 2433 9534 V 2466 9534 V 737 w(13)p 3086 9534 V 476 w(13)p
+ 3716 9534 V 491 w(0)p 4284 9534 V 461 w(13)p 4899 9534
+ V 566 w(0)p 5542 9534 V 658 w(0)p 6277 9534 V 1468 9540
+ 4813 7 v 1775 9932 a Fx(T)-15 b(able)60 b(4.2:)80 b(No)5
+ b(de)61 b(A)-5 b(ttributes)59 b(for)h(Simple)f(Lo)5 b(op)60
+ b(Example)273 10680 y Fr(\017)91 b Fq(AS)10 b(AP)965
+ 10707 y Fh(u)1056 10680 y Fx(:)96 b(The)68 b(As)g(So)5
+ b(on)68 b(As)h(P)-5 b(ossible)66 b(attribute)g(indicates)h(the)g
+ (earliest)g(time)g(that)g(the)h(instruction)3809 11136
+ y(35)p eop end
+ %%Page: 36 43
+ TeXDict begin 36 42 bop 455 183 a Fx(ma)-5 b(y)59 b(b)5
+ b(e)61 b(sc)-5 b(heduled.)79 b(It)60 b(is)g(computed)f(as)h(follo)-5
+ b(ws:)646 822 y Fq(I)14 b(f)81 b(P)25 b(r)5 b(ed)p Fx(\()p
+ Fq(u)p Fx(\))59 b(=)i Fr(f)g(g)838 1187 y Fq(AS)10 b(AP)1348
+ 1214 y Fh(u)1500 1187 y Fx(=)61 b(0)646 1553 y Fq(el)t(se)838
+ 1918 y(AS)10 b(AP)1348 1945 y Fh(u)1500 1918 y Fx(=)61
+ b Fq(max)2062 1955 y Fg(8)p Fh(v)5 b(\017P)20 b(r)t(ed)p
+ Fo(\()p Fh(u)p Fo(\))2846 1918 y Fx(\()p Fq(AS)10 b(AP)3427
+ 1945 y Fh(v)3571 1918 y Fx(+)61 b Fq(\025)3879 1945 y
+ Fh(v)4021 1918 y Fx(+)g Fq(\016)4304 1945 y Fh(v)5 b(;u)4567
+ 1918 y Fr(\003)61 b Fq(M)20 b(I)14 b(I)g Fx(\))273 2557
+ y Fr(\017)91 b Fq(ALAP)968 2584 y Fh(u)1058 2557 y Fx(:)99
+ b(The)70 b(As)g(Late)g(As)g(P)-5 b(ossible)68 b(attribute)g(determines)
+ g(the)i(latest)f(cycle)f(an)i(instruction)f(ma)-5 b(y)455
+ 2923 y(b)5 b(e)60 b(sc)-5 b(heduled.)79 b(It)60 b(is)g(computed)f
+ (using)h(the)g(follo)-5 b(wing:)646 3562 y Fq(I)14 b(f)81
+ b(S)10 b(ucc)p Fx(\()p Fq(u)p Fx(\))60 b(=)h Fr(f)g(g)838
+ 3928 y Fq(ALAP)1351 3955 y Fh(u)1502 3928 y Fx(=)g Fq(max)2064
+ 3958 y Fg(8)p Fh(v)5 b(\017V)2455 3928 y Fq(AS)10 b(AP)2965
+ 3955 y Fh(v)646 4293 y Fq(el)t(se)838 4658 y(ALAP)1351
+ 4685 y Fh(u)1502 4658 y Fx(=)61 b Fq(min)2036 4695 y
+ Fg(8)p Fh(v)5 b(\017S)i(ucc)p Fo(\()p Fh(u)p Fo(\))2802
+ 4658 y Fx(\()p Fq(ALAP)3386 4685 y Fh(v)3529 4658 y Fr(\000)61
+ b Fq(\025)3837 4685 y Fh(u)3987 4658 y Fx(+)g Fq(\016)4270
+ 4685 y Fh(u;v)4533 4658 y Fr(\003)g Fq(M)20 b(I)14 b(I)g
+ Fx(\))273 5298 y Fr(\017)91 b Fq(M)20 b(O)5 b(B)933 5325
+ y Fh(u)1022 5298 y Fx(:)89 b(The)64 b(Mobilit)-5 b(y)63
+ b(of)h(an)g(instruction)f(is)h(the)g(n)-5 b(um)g(b)5
+ b(er)64 b(of)g(time)f(slots)h(that)f(an)i(instruction)e(ma)-5
+ b(y)455 5663 y(b)5 b(e)53 b(sc)-5 b(heduled)53 b(in.)77
+ b(The)54 b(lo)-5 b(w)g(er)53 b(the)h(v)-10 b(alue,)53
+ b(the)h(more)f(critical)f(the)h(no)5 b(de)53 b(and)h(a)g(MOB)f(of)h
+ (zero)f(indicates)455 6028 y(the)60 b(most)f(critical)g(path.)80
+ b(This)60 b(attribute)f(is)h(calculated)e(as)j(follo)-5
+ b(ws:)646 6668 y Fq(M)20 b(O)5 b(B)1124 6695 y Fh(u)1275
+ 6668 y Fx(=)61 b Fq(ALAP)1990 6695 y Fh(u)2141 6668 y
+ Fr(\000)g Fq(AS)10 b(AP)2853 6695 y Fh(u)273 7307 y Fr(\017)91
+ b Fq(D)606 7334 y Fh(u)695 7307 y Fx(:)99 b(The)70 b(Depth)f(of)h(a)g
+ (no)5 b(de)69 b(is)g(the)h(n)-5 b(um)g(b)5 b(er)69 b(of)g(no)5
+ b(des)70 b(or)g(maxim)-5 b(um)68 b(distance)g(b)5 b(et)-5
+ b(w)g(een)69 b(this)g(no)5 b(de)455 7672 y(and)60 b(a)h(no)5
+ b(de)60 b(with)g(no)h(predecessors.)79 b(It)60 b(is)g(computed)f(as)h
+ (follo)-5 b(ws:)646 8312 y Fq(I)14 b(f)81 b(P)25 b(r)5
+ b(ed)p Fx(\()p Fq(u)p Fx(\))59 b(=)i Fr(f)g(g)838 8677
+ y Fq(D)989 8704 y Fh(u)1140 8677 y Fx(=)g(0)646 9043
+ y Fq(el)t(se)838 9408 y(D)989 9435 y Fh(u)1140 9408 y
+ Fx(=)g Fq(max)1702 9445 y Fg(8)p Fh(v)5 b(\017P)20 b(r)t(ed)p
+ Fo(\()p Fh(u)p Fo(\))2485 9408 y Fx(\()p Fq(D)2707 9435
+ y Fh(v)2849 9408 y Fx(+)61 b Fq(\025)3157 9435 y Fh(v)3239
+ 9408 y Fx(\))273 10047 y Fr(\017)91 b Fq(H)606 10074
+ y Fh(u)696 10047 y Fx(:)i(The)67 b(Heigh)-5 b(t)66 b(of)g(a)h(no)5
+ b(de)66 b(is)g(the)h(maxim)-5 b(um)65 b(distance)g(b)5
+ b(et)-5 b(w)g(een)66 b(this)g(no)5 b(de)67 b(and)f(a)h(no)5
+ b(de)67 b(without)455 10413 y(successors.)78 b(It)60
+ b(is)g(calculated)f(as)h(follo)-5 b(ws:)3809 11136 y(36)p
+ eop end
+ %%Page: 37 44
+ TeXDict begin 37 43 bop 646 256 a Fq(I)14 b(f)81 b(S)10
+ b(ucc)p Fx(\()p Fq(u)p Fx(\))60 b(=)h Fr(f)g(g)838 621
+ y Fq(H)989 648 y Fh(u)1140 621 y Fx(=)g(0)646 987 y Fq(el)t(se)838
+ 1352 y(H)989 1379 y Fh(u)1140 1352 y Fx(=)g Fq(max)1702
+ 1389 y Fg(8)p Fh(v)5 b(\017S)i(ucc)p Fo(\()p Fh(u)p Fo(\))2468
+ 1352 y Fx(\()p Fq(H)2690 1379 y Fh(v)2833 1352 y Fx(+)61
+ b Fq(\025)3141 1379 y Fh(u)3231 1352 y Fx(\))282 1991
+ y(T)-15 b(able)89 b(4.2)f(sho)-5 b(ws)89 b(the)g(calculated)e(prop)5
+ b(erties)88 b(for)h(all)f(the)h(no)5 b(des)89 b(in)g(the)f(data)h(dep)5
+ b(endence)88 b(graph.)0 2357 y(Lo)5 b(oking)72 b(at)h(this)f(table,)j
+ (w)-5 b(e)73 b(can)g(see)f(that)h(there)g(are)g(a)g(few)g(long)f
+ (latency)g(instructions)f(\(fm)-5 b(uls)71 b(\(n35\),)k(ld)0
+ 2722 y(\(n25\),)58 b(ld)h(\(n22\)\))f(whic)-5 b(h)59
+ b(should)g(ideally)e(b)5 b(e)59 b(o)-5 b(v)g(erlapp)5
+ b(ed)59 b(with)f(other)h(instructions.)78 b(The)60 b(no)5
+ b(des)58 b(with)h(a)g(lo)-5 b(w)0 3087 y(Mobilit)g(y)46
+ b(and)j(high)f(Heigh)-5 b(t)47 b(are)i(those)e(instructions)g(that)g
+ (are)i(considered)e(on)i(the)f(critical)e(path.)76 b(The)49
+ b(ASAP)0 3453 y(and)66 b(ALAP)h(v)-10 b(alues)65 b(giv)-5
+ b(e)65 b(some)g(indication)f(as)i(to)g(ho)-5 b(w)67 b(early)e(or)i(ho)
+ -5 b(w)66 b(late)f(instructions)f(can)i(b)5 b(e)66 b(sc)-5
+ b(heduled)0 3818 y(based)60 b(up)5 b(on)61 b(latencies)d(of)i
+ (predecessors)f(and)i(successors.)0 4576 y Ft(4.5)270
+ b(No)7 b(de)91 b(Ordering)0 5121 y Fx(The)62 b(no)5 b(de)62
+ b(ordering)g(step)g(is)f(a)h(sophisticated)e(algorithm)g(that)i(uses)f
+ (the)h(data)g(dep)5 b(endence)61 b(graph)h(and)g(the)0
+ 5486 y(no)5 b(de)75 b(attributes)e(to)i(create)f(a)h(sc)-5
+ b(heduling)74 b(order.)123 b(The)76 b(ordering)e(algorithm)g(is)g(used)
+ g(to)h(giv)-5 b(e)74 b(priorit)-5 b(y)74 b(to)0 5852
+ y(instructions)46 b(that)i(are)g(on)g(the)g(most)f(critical)f(paths,)k
+ (while)d(k)-5 b(eeping)47 b(register)h(pressure)f(lo)-5
+ b(w.)76 b(It)48 b(accomplishes)0 6217 y(the)64 b(\014rst)g(b)-5
+ b(y)64 b(using)g(heuristics)e(to)i(sc)-5 b(hedule)64
+ b(instructions)e(with)i(the)g(highest)f(mobilit)-5 b(y)62
+ b(last.)91 b(The)64 b(second)g(is)0 6583 y(ac)-5 b(hiev)g(ed)62
+ b(b)-5 b(y)63 b(ordering)g(instructions)e(suc)-5 b(h)63
+ b(that)f(no)h(instruction)f(is)g(sc)-5 b(heduled)62 b(after)g(b)5
+ b(oth)63 b(its)f(predecessors)0 6948 y(and)53 b(successors.)76
+ b(By)52 b(k)-5 b(eeping)52 b(an)g(instruction)f(close)g(to)i(its)e
+ (predecessors)h(and)g(successors,)g(liv)-5 b(e)52 b(v)-10
+ b(alue)51 b(ranges)0 7313 y(are)70 b(decreased.)106 b(The)70
+ b(only)f(exception)f(is)h(for)g(recurrences,)i(where)f(one)f
+ (instruction)f(is)h(sc)-5 b(heduled)68 b(after)h(its)0
+ 7679 y(predecessors)59 b(and)i(successors)e(\(whic)-5
+ b(h)60 b(can)g(not)g(b)5 b(e)61 b(a)-5 b(v)g(oided\).)1761
+ 8143 y Fs(1)197 b Fm(P)64 b Fs(=)51 b(Empt)l(y)g(ordered)h(list)e(of)h
+ (sets)f(of)h(no)t(des)1761 8325 y(2)197 b(while)51 b(\()p
+ Fm(R)q(ecc)2816 8342 y Fe(List)3102 8325 y Fn(6)p Fs(=)h
+ Fn(;)p Fs(\))1761 8508 y(3)359 b Fm(R)q(ecc)44 b Fs(=)52
+ b Fn(f)p Fs(Recurrence)h(with)e(highest)g(RecMI)t(I)p
+ Fn(g)1761 8691 y Fs(4)359 b(if)50 b(\()p Fm(P)64 b Fs(=)52
+ b Fn(;)p Fs(\))1761 8873 y(5)521 b Fm(P)64 b Fs(=)51
+ b Fm(P)73 b Fn(j)51 b Fm(R)q(ecc)1761 9056 y Fs(6)359
+ b(else)1761 9239 y(7)521 b Fn(8)51 b Fm(v)5 b Fs(,)51
+ b(where)h Fm(v)k Fs(are)c(no)t(des)g(connecting)g Fm(R)q(ecc)g
+ Fs(to)f(an)l(y)g(set)g(in)g Fm(P)1761 9421 y Fs(8)683
+ b Fm(R)q(ecc)44 b Fs(=)52 b Fm(R)q(ecc)h Fn(j)e Fm(v)1761
+ 9604 y Fs(9)521 b Fm(P)64 b Fs(=)51 b Fm(P)73 b Fn(j)51
+ b Fm(R)q(ecc)1761 9786 y Fs(10)120 b Fm(N)16 b(odesLef)g(t)42
+ b Fs(=)52 b Fn(f)p Fs(All)e(no)t(des)i(not)f(in)g(P)p
+ Fn(g)1761 9969 y Fs(11)120 b Fn(8)51 b Fs(connected)i(comp)t(onen)l
+ (ts,)e Fm(C)11 b Fs(,)50 b Fn(2)i Fm(N)16 b(odesLef)g(t)1761
+ 10152 y Fs(12)282 b Fm(P)64 b Fs(=)51 b Fm(P)73 b Fn(j)51
+ b Fm(C)1412 10672 y Fx(Figure)60 b(4.7:)79 b(Pseudo)60
+ b(Co)5 b(de)61 b(for)f(P)-5 b(artial)59 b(No)5 b(de)61
+ b(Ordering)f(Algorithm)3809 11136 y(37)p eop end
+ %%Page: 38 45
+ TeXDict begin 38 44 bop 282 183 a Fx(The)60 b(ordering)f(algorithm)f(b)
+ 5 b(egins)59 b(b)-5 b(y)60 b(calculating)d(a)j(partial)e(order,)i(a)f
+ (list)f(of)h(sets)g(of)g(no)5 b(des.)80 b(Figure)59 b(4.7)0
+ 548 y(describ)5 b(e)45 b(the)g(partial)f(no)5 b(de)46
+ b(ordering)f(algorithm,)i(where)f Fr(j)f Fx(denotes)g(the)g(list)f(app)
+ 5 b(end)46 b(op)5 b(eration.)74 b(F)-15 b(or)45 b(a)h(graph)0
+ 913 y(with)69 b(recurrences,)h(the)f(\014rst)g(set)f(in)h(the)g
+ (partial)f(order)h(list)f(is)g(the)h(recurrence)g(with)f(the)h(highest)
+ f(RecMI)5 b(I.)0 1279 y(The)71 b(next)g(highest)f(RecMI)5
+ b(I)70 b(recurrence)h(set)f(is)g(app)5 b(ended)71 b(to)g(the)g(partial)
+ f(list)f(including)h(an)-5 b(y)71 b(no)5 b(des)71 b(that)0
+ 1644 y(connect)c(it)h(to)f(an)-5 b(y)68 b(recurrence)g(already)g(in)f
+ (the)h(partial)f(order,)j(and)e(remo)-5 b(ving)67 b(an)-5
+ b(y)68 b(no)5 b(des)67 b(already)h(in)f(the)0 2010 y(partial)59
+ b(order.)80 b(This)59 b(is)g(rep)5 b(eated)60 b(un)-5
+ b(til)58 b(all)h(recurrences)g(ha)-5 b(v)g(e)60 b(b)5
+ b(een)59 b(added.)80 b(If)59 b(there)g(are)h(no)5 b(des)60
+ b(not)f(in)g(the)0 2375 y(partial)d(order)h(or)g(the)f(graph)h(has)g
+ (no)g(recurrences,)f(no)5 b(des)57 b(are)g(group)5 b(ed)57
+ b(in)-5 b(to)56 b(connected)f(comp)5 b(onen)-5 b(ts,)56
+ b(a)h(set)0 2740 y(of)j(no)5 b(des)60 b(that)g(are)h(connected,)e(and)h
+ (the)g(set)g(is)g(app)5 b(ended)60 b(to)g(the)h(partial)e(order.)282
+ 3106 y(Figure)d(4.8)f(sho)-5 b(ws)56 b(the)g(partial)f(order)i(for)f
+ (our)g(simple)f(lo)5 b(op)56 b(example.)77 b(The)57 b(partial)e(order)h
+ (is)g(an)g(ordered)0 3471 y(list)61 b(of)g(sets.)85 b(The)62
+ b(\014rst)g(set)g(consists)e(of)i(no)5 b(des)62 b(from)f(the)h(lone)f
+ (recurrence)h(in)g(the)g(dep)5 b(endence)61 b(graph.)86
+ b(The)0 3836 y(other)69 b(sets)g(represen)-5 b(t)69 b(the)g(connected)f
+ (comp)5 b(onen)-5 b(ts)68 b(in)h(the)g(graph)h(\(min)-5
+ b(us)68 b(the)h(recurrence\).)107 b(There)69 b(is)g(no)0
+ 4202 y(order)61 b(in)f(whic)-5 b(h)60 b(the)g(connected)g(comp)5
+ b(onen)-5 b(ts)59 b(are)h(added.)282 4567 y(Once)f(the)e(partial)g
+ (order)i(has)f(b)5 b(een)58 b(computed,)f(the)h(\014nal)f(no)5
+ b(de)58 b(ordering)g(algorithm)f(pro)5 b(duces)58 b(a)g(list)f(of)0
+ 4933 y(no)5 b(des)72 b(that)g(is)g(sen)-5 b(t)72 b(to)g(the)h(sc)-5
+ b(heduler.)115 b(The)73 b(algorithm)e(sho)-5 b(wn)72
+ b(in)h(Figure)e(4.9)h(tra)-5 b(v)g(erses)72 b(eac)-5
+ b(h)72 b(subgraph)0 5298 y(of)80 b(the)f(set)h(of)f(no)5
+ b(des)80 b(in)g(the)f(partial)g(order.)139 b(In)80 b(the)g(case)f(of)h
+ (a)g(connected)f(dep)5 b(endence)79 b(graph)h(with)g(no)0
+ 5663 y(recurrences,)60 b(it)f(tra)-5 b(v)g(erses)60 b(the)g(whole)g
+ (graph.)282 6029 y(The)66 b(algorithm)e(b)5 b(egins)64
+ b(with)h(the)g(no)5 b(de)66 b(at)f(the)g(b)5 b(ottom)64
+ b(of)h(the)g(most)f(critical)g(path)h(and)g(visits)f(all)g(the)0
+ 6394 y(ancestors)50 b(according)h(to)h(their)e(depth,)j(tra)-5
+ b(v)g(eling)50 b(b)5 b(ottom-up.)76 b(If)51 b(the)g(ancestors)f(ha)-5
+ b(v)g(e)52 b(equal)f(depth,)h(priorit)-5 b(y)0 6759 y(is)79
+ b(giv)-5 b(en)79 b(to)g(no)5 b(des)80 b(with)f(less)g(mobilit)-5
+ b(y)-15 b(.)135 b(Once)80 b(all)f(the)g(ancestors)g(are)g(visited,)k
+ (the)c(descendan)-5 b(ts)78 b(of)h(the)0 7125 y(no)5
+ b(de)67 b(are)h(visited)e(in)h(order)h(of)f(heigh)-5
+ b(t,)67 b(tra)-5 b(v)g(ersing)67 b(top-do)-5 b(wn.)101
+ b(This)67 b(up)-5 b(w)g(ard)68 b(and)f(do)-5 b(wn)g(w)g(ard)68
+ b(tra)-5 b(v)g(ersal)67 b(is)0 7490 y(rep)5 b(eated)50
+ b(un)-5 b(til)48 b(all)i(no)5 b(des)49 b(ha)-5 b(v)g(e)50
+ b(b)5 b(een)50 b(placed)f(in)h(the)g(\014nal)g(order)g(and)g(the)g(en)
+ -5 b(tire)49 b(graph)h(has)g(b)5 b(een)50 b(tra)-5 b(v)g(ersed.)0
+ 7817 y Fd(Set)69 b(#1:)h(ld)f(\(n25\),)f(fmuls)h(\(n34\),)f(st)h
+ (\(n35\))0 7975 y(Set)g(#2:)h(sethi)e(\(n2\),)g(or)i(\(n5\),)f(sllx)f
+ (\(n11\),)g(or)i(\(n15\),)e(or)i(\(n17\),)e(add)h(\(n21\),)f(sethi)g
+ (\(n6\))0 8132 y(Set)h(#3:)h(sethi)e(\(n10\),)g(sethi)g(\(n4\),)h(or)h
+ (\(n7\),)e(sllx)h(\(n12\),)f(or)h(\(n13\),)f(or)i(\(n19\),)e(ld)i
+ (\(n22\))0 8290 y(Set)f(#4:)h(sethi)e(\(n1\),)g(or)i(\(n8\),)f(add)g
+ (\(n9\),)f(srl)h(\(n16\),)f(sll)i(\(n18\),)0 8448 y(Set)f(#5:)h(sethi)e
+ (\(n14\),)g(or)i(\(n20\),)e(sllx)h(\(n23\),)e(or)j(\(n27\),)e(or)i
+ (\(n29\),)e(add)h(\(n32\),)f(sethi)h(\(n24\))0 8606 y(Set)g(#7:)h(sll)f
+ (\(n26\))1990 9197 y Fx(Figure)60 b(4.8:)79 b(Simple)59
+ b(Lo)5 b(op)60 b(Example)f(P)-5 b(artial)59 b(Order)282
+ 9761 y(The)42 b(\014nal)g(no)5 b(de)42 b(ordering)f(algorithm)f(sho)-5
+ b(wn)42 b(in)g(Figure)f(4.9,)j(uses)d Fr(j)h Fx(to)g(denote)f(the)g
+ (list)g(app)5 b(end)41 b(op)5 b(eration,)0 10127 y(and)61
+ b(Succ)p 729 10127 55 7 v 65 w(L\(O\))f(and)g(Pred)p
+ 1981 10127 V 65 w(L\(O\))h(are)f(de\014ned)g(as)h(follo)-5
+ b(ws:)282 10492 y(Pred)p 670 10492 V 65 w(L\(O\))61 b(=)g
+ Fr(f)p Fq(v)67 b Fr(j)60 b(9)g Fq(u)51 b Fr(2)61 b Fq(O)k
+ Fx(where)c Fq(v)c Fr(2)k Fq(P)25 b(r)5 b(ed)p Fx(\()p
+ Fq(u)p Fx(\))59 b(and)i Fq(v)c Fr(3)k Fq(O)5 b Fr(g)3809
+ 11136 y Fx(38)p eop end
+ %%Page: 39 46
+ TeXDict begin 39 45 bop 282 183 a Fx(Succ)p 657 183 55
+ 7 v 65 w(L\(O\))60 b(=)h Fr(f)p Fq(v)68 b Fr(j)60 b(9)g
+ Fq(u)51 b Fr(2)61 b Fq(O)k Fx(where)c Fq(v)c Fr(2)k Fq(S)10
+ b(ucc)p Fx(\()p Fq(u)p Fx(\))60 b(and)h Fq(v)c Fr(3)k
+ Fq(O)5 b Fr(g)1068 632 y Fs(1)196 b Fm(O)47 b Fs(=)52
+ b(Empt)l(y)p 2140 632 47 7 v 54 w(List)1068 815 y(2)196
+ b(foreac)l(h)52 b Fm(S)187 b Fs(//Eac)l(h)50 b(set)h(in)g(the)h
+ (partial)e(order)i(in)f(decreasing)h(priorit)l(y)1068
+ 998 y(3)358 b(if)51 b(\(\(Pred)p 2091 998 V 55 w(L\()p
+ Fm(O)t Fs(\))g Fn(\\)h Fm(S)8 b Fs(\))51 b Fn(6)p Fs(=)g
+ Fn(;)p Fs(\))1068 1180 y(4)521 b Fm(R)43 b Fs(=)52 b(Pred)p
+ 2323 1180 V 56 w(L\()p Fm(O)t Fs(\))e Fn(\\)i Fm(S)1068
+ 1363 y Fs(5)521 b Fm(or)t(der)48 b Fs(=)j(b)t(ottom-up)1068
+ 1546 y(6)358 b(else)52 b(if\(\(Succ)p 2320 1546 V 55
+ w(L\()p Fm(O)t Fs(\))f Fn(\\)g Fm(S)8 b Fs(\))52 b Fn(6)p
+ Fs(=)f Fn(;)p Fs(\))1068 1728 y(7)521 b Fm(R)43 b Fs(=)52
+ b(Succ)p 2311 1728 V 57 w(L\()p Fm(O)t Fs(\))e Fn(\\)i
+ Fm(S)1068 1911 y Fs(8)521 b Fm(or)t(der)48 b Fs(=)j(top-do)l(wn)1068
+ 2093 y(9)358 b(else)1068 2276 y(10)444 b Fm(R)43 b Fs(=)52
+ b Fn(f)p Fs(No)t(de)g(with)f(the)g(highest)g(ASAP)h(in)f(S,)g(pic)l(k)g
+ (an)l(y)g(if)g(more)h(then)g(one)p Fn(g)1068 2459 y Fs(11)444
+ b Fm(or)t(der)48 b Fs(=)j(b)t(ottom-up)1068 2641 y(12)119
+ b(while)51 b(\()p Fm(R)44 b Fn(6)p Fs(=)52 b Fn(;)p Fs(\))1068
+ 2824 y(13)281 b(if)51 b(\()p Fm(or)t(der)d Fs(=)k(top-do)l(wn\))1068
+ 3007 y(14)444 b(while)51 b(\()p Fm(R)43 b Fn(6)p Fs(=)52
+ b Fn(;)p Fs(\))1068 3189 y(15)606 b Fm(V)76 b Fs(=)52
+ b Fn(f)p Fs(Elemen)l(t)e(of)h(R)g(with)g(highest)g(Heigh)l(t.)68
+ b(Use)51 b(highest)g(MOB)g(to)g(break)h(ties)p Fn(g)1068
+ 3372 y Fs(16)606 b Fm(O)46 b Fs(=)52 b Fm(O)j Fn(j)c
+ Fm(V)1068 3555 y Fs(17)606 b Fm(R)44 b Fs(=)51 b(\()p
+ Fm(R)q Fn(\000)h Fm(V)34 b Fs(\))51 b Fn([)g Fs(\(Succ\(V\))h
+ Fn(\\)f Fm(S)8 b Fs(\))1068 3737 y(18)444 b Fm(or)t(der)48
+ b Fs(=)j(b)t(ottom-up)1068 3920 y(19)444 b Fm(R)43 b
+ Fs(=)52 b(Pred)p 2323 3920 V 56 w(L\()p Fm(O)t Fs(\))e
+ Fn(\\)i Fm(S)1068 4103 y Fs(20)281 b(else)1068 4285 y(21)444
+ b(while)51 b(\()p Fm(R)43 b Fn(6)p Fs(=)52 b Fn(;)p Fs(\))1068
+ 4468 y(22)606 b Fm(V)76 b Fs(=)52 b Fn(f)p Fs(Elemen)l(t)e(of)h(R)g
+ (with)g(highest)g(Depth.)69 b(Use)51 b(lo)l(w)l(est)f(MOB)h(to)g(break)
+ h(ties)p Fn(g)1068 4651 y Fs(23)606 b Fm(O)46 b Fs(=)52
+ b Fm(O)j Fn(j)c Fm(V)1068 4833 y Fs(24)606 b Fm(R)44
+ b Fs(=)51 b(\()p Fm(R)q Fn(\000)h Fm(V)34 b Fs(\))51
+ b Fn([)g Fs(\(Pred\(V\))g Fn(\\)h Fm(S)8 b Fs(\))1068
+ 5016 y(25)444 b Fm(or)t(der)48 b Fs(=)j(top-do)l(wn)1068
+ 5199 y(26)444 b Fm(R)43 b Fs(=)52 b(Succ)p 2311 5199
+ V 57 w(L\()p Fm(O)t Fs(\))e Fn(\\)i Fm(S)1478 5718 y
+ Fx(Figure)60 b(4.9:)79 b(Pseudo)60 b(Co)5 b(de)61 b(for)f(Final)f(No)5
+ b(de)61 b(Ordering)g(Algorithm)282 6146 y(F)-15 b(or)54
+ b(the)g(lo)5 b(op)53 b(example,)h(the)f(Final)g(No)5
+ b(de)54 b(ordering)g(algorithm)e(pro)5 b(cesses)53 b(eac)-5
+ b(h)53 b(set)h(in)f(the)h(partial)f(order)0 6511 y(and)61
+ b(determines)d(the)i(\014nal)g(no)5 b(de)61 b(ordering)f(to)g(b)5
+ b(e)61 b(the)f(follo)-5 b(wing:)282 6876 y Fq(O)82 b
+ Fx(=)77 b Fr(f)p Fx(st)f(\(n35\),)j(fm)-5 b(uls)74 b(\(n34\),)80
+ b(ld)c(\(n25\),)j(sll)c(\(n18\),)k(srl)d(\(n16\),)j(add)e(\(n9\),)i(or)
+ d(\(n8\),)k(sethi)75 b(\(n1\),)k(add)0 7242 y(\(n21\),)61
+ b(or)h(\(n15\),)f(sllx)f(\(n11\),)h(or)h(\(n5\),)f(sethi)f(\(n2\),)h
+ (ld)h(\(n22\),)f(or)g(\(19\),)g(or)h(\(n13\),)f(sllx)g(\(n12\),)f(or)i
+ (\(n7\),)f(sethi)0 7607 y(\(n4\),)68 b(sethi)e(\(n6\),)i(sethi)e
+ (\(n10\),)i(add)g(\(n32\),)g(or)f(\(n29\),)h(or)g(\(n27\),)g(sllx)e
+ (\(n23\),)i(or)f(\(n20\),)h(sethi)e(\(n14\),)i(sethi)0
+ 7973 y(\(n24\),)59 b(sll)h(\(n26\))p Fr(g)0 8723 y Ft(4.6)270
+ b(Sc)-7 b(heduling)0 9269 y Fx(The)57 b(sc)-5 b(heduling)55
+ b(phase)i(of)f(Swing)h(Mo)5 b(dulo)56 b(Sc)-5 b(heduling)56
+ b(sc)-5 b(hedules)55 b(the)i(no)5 b(des)56 b(in)h(the)f(order)i
+ (determined)d(b)-5 b(y)0 9634 y(the)67 b(no)5 b(de)67
+ b(ordering)f(algorithm.)98 b(Conceptually)66 b(a)h(sc)-5
+ b(hedule)66 b(is)g(a)h(table)f(where)i(the)e(ro)-5 b(ws)68
+ b(represen)-5 b(t)66 b(cycles,)0 10000 y(and)e(columns)f(are)i(issue)e
+ (slots)2237 9934 y Fo(4)2316 10000 y Fx(.)92 b(Sc)-5
+ b(heduling)63 b(an)h(instruction)f(reserv)-5 b(es)64
+ b(an)g(issue)f(slot)h(for)g(a)g(sp)5 b(eci\014c)64 b(cycle.)0
+ 10365 y(The)58 b(com)-5 b(bination)56 b(of)h(instructions)e(that)j(can)
+ f(b)5 b(e)58 b(group)5 b(ed)58 b(together)e(in)i(the)f(issue)g(slots)f
+ (is)h(dep)5 b(enden)-5 b(t)57 b(up)5 b(on)p 0 10509 3120
+ 7 v 207 10617 a Fl(4)276 10680 y Fs(Our)53 b(implemen)l(tation)d(\(for)
+ h(the)g(SP)-13 b(AR)l(C)52 b(I)t(I)t(Ii\))g(has)f(4)g(issue)g(slots.)
+ 3809 11136 y Fx(39)p eop end
+ %%Page: 40 47
+ TeXDict begin 40 46 bop 0 183 a Fx(the)74 b(arc)-5 b(hitecture)74
+ b(and)h(resources.)122 b(If)74 b(all)g(instructions)e(ha)-5
+ b(v)g(e)75 b(not)f(b)5 b(een)75 b(sc)-5 b(heduled,)76
+ b(the)f(table)f(is)g(called)f(a)0 548 y(partial)59 b(sc)-5
+ b(hedule.)282 913 y(When)52 b(sc)-5 b(heduling)49 b(instructions,)i
+ (SMS)g(attempts)f(to)h(place)g(instructions)e(as)i(close)f(to)h(their)g
+ (predecessors)0 1279 y(or)85 b(successors)e(in)h(the)g(partial)f(sc)-5
+ b(hedule.)150 b(By)85 b(placing)e(instructions)f(close)h(to)h(their)g
+ (neigh)-5 b(b)5 b(ors,)89 b(register)0 1644 y(pressure)60
+ b(is)g(reduced.)847 2070 y Fs(1)196 b Fn(8)p Fm(n)52
+ b Fn(2)f Fm(O)847 2253 y Fs(2)359 b(if)50 b(\(\(Succ\()p
+ Fm(n)p Fs(\))h Fn(2)h Fm(P)21 b(S)8 b Fs(\))51 b(&&)i(\(Pred\()p
+ Fm(n)p Fs(\))d Fn(2)h Fm(P)21 b(S)8 b Fs(\)\))847 2435
+ y(3)521 b Fm(E)9 b(S)f(tar)t(t)44 b Fs(=)52 b Fm(max)2451
+ 2458 y Fe(v)t Fc(2)p Fe(P)16 b(S)5 b(P)16 b Fl(\()p Fe(u)p
+ Fl(\))3046 2435 y Fs(\()p Fm(t)3161 2452 y Fe(v)3236
+ 2435 y Fs(+)51 b Fm(\025)3496 2452 y Fe(v)3570 2435 y
+ Fn(\000)h Fm(\016)3809 2452 y Fe(v)t(;u)3994 2435 y Fn(\003)f
+ Fm(I)12 b(I)g Fs(\))847 2618 y(4)521 b Fm(LS)8 b(tar)t(t)44
+ b Fs(=)52 b Fm(max)2434 2641 y Fe(v)t Fc(2)p Fe(P)16
+ b(S)5 b(S)g Fl(\()p Fe(u)p Fl(\))3016 2618 y Fs(\()p
+ Fm(t)3131 2635 y Fe(v)3205 2618 y Fn(\000)52 b Fm(\025)3466
+ 2635 y Fe(u)3547 2618 y Fn(\000)g Fm(\016)3786 2635 y
+ Fe(u;v)3972 2618 y Fn(\003)f Fm(I)12 b(I)g Fs(\))847
+ 2801 y(5)521 b(Sc)l(hedule)52 b(no)t(de)h(in)e(free)h(slot)e(starting)g
+ (from)h Fm(E)9 b(S)f(tar)t(t)52 b Fs(un)l(til)f(min\()p
+ Fm(LS)8 b(tar)t(t)p Fs(,)52 b Fm(E)9 b(S)f(tar)t(t)p
+ Fs(+)54 b Fm(I)12 b(I)g Fn(\000)51 b Fs(1)847 2983 y(6)359
+ b(else)51 b(if)f(\(Pred\()p Fm(n)p Fs(\))h Fn(2)g Fm(P)21
+ b(S)8 b Fs(\))847 3166 y(7)521 b Fm(E)9 b(S)f(tar)t(t)44
+ b Fs(=)52 b Fm(max)2451 3189 y Fe(v)t Fc(2)p Fe(P)16
+ b(S)5 b(P)16 b Fl(\()p Fe(u)p Fl(\))3046 3166 y Fs(\()p
+ Fm(t)3161 3183 y Fe(v)3236 3166 y Fs(+)51 b Fm(\025)3496
+ 3183 y Fe(v)3570 3166 y Fn(\000)h Fm(\016)3809 3183 y
+ Fe(v)t(;u)3994 3166 y Fn(\003)f Fm(I)12 b(I)g Fs(\))847
+ 3349 y(8)521 b(Sc)l(hedule)52 b(no)t(de)h(in)e(free)h(slot)e(starting)g
+ (from)h Fm(E)9 b(S)f(tar)t(t)52 b Fs(un)l(til)f Fm(E)9
+ b(S)f(tar)t(t)p Fs(+)53 b Fm(I)12 b(I)g Fn(\000)52 b
+ Fs(1)847 3531 y(9)359 b(else)51 b(if)f(\(Succ\()p Fm(n)p
+ Fs(\))i Fn(2)f Fm(P)21 b(S)8 b Fs(\))847 3714 y(10)444
+ b Fm(LS)8 b(tar)t(t)44 b Fs(=)52 b Fm(max)2434 3737 y
+ Fe(v)t Fc(2)p Fe(P)16 b(S)5 b(S)g Fl(\()p Fe(u)p Fl(\))3016
+ 3714 y Fs(\()p Fm(t)3131 3731 y Fe(v)3205 3714 y Fn(\000)52
+ b Fm(\025)3466 3731 y Fe(u)3547 3714 y Fn(\000)g Fm(\016)3786
+ 3731 y Fe(u;v)3972 3714 y Fn(\003)f Fm(I)12 b(I)g Fs(\))847
+ 3897 y(11)444 b(Sc)l(hedule)52 b(no)t(de)h(in)e(free)h(slot)e(starting)
+ g(from)h Fm(LS)8 b(tar)t(t)52 b Fs(un)l(til)f Fm(LS)8
+ b(tar)t(t)p Fn(\000)53 b Fm(I)12 b(I)g Fs(+)52 b(1)847
+ 4079 y(12)282 b(else)847 4262 y(13)444 b Fm(E)9 b(S)f(tar)t(t)44
+ b Fs(=)52 b Fm(AS)8 b(AP)2578 4279 y Fe(u)847 4445 y
+ Fs(14)444 b(Sc)l(hedule)52 b(no)t(de)h(in)e(free)h(slot)e(starting)g
+ (from)h Fm(E)9 b(S)f(tar)t(t)52 b Fs(un)l(til)f Fm(E)9
+ b(S)f(tar)t(t)p Fs(+)53 b Fm(I)12 b(I)g Fn(\000)52 b
+ Fs(1)847 4627 y(15)282 b(if)50 b(\(!sc)l(heduled\))847
+ 4810 y(16)444 b Fm(I)12 b(I)54 b Fs(=)e Fm(I)12 b(I)g
+ Fs(+)51 b(1)847 4993 y(17)444 b(Clear)51 b(sc)l(hedule)h(and)f(restart)
+ 1833 5512 y Fx(Figure)60 b(4.10:)79 b(Pseudo)60 b(Co)5
+ b(de)61 b(for)f(Sc)-5 b(heduling)59 b(Algorithm)282 5936
+ y(Figure)77 b(4.10)f(sho)-5 b(ws)77 b(the)g(SMS)g(sc)-5
+ b(heduling)76 b(algorithm,)j(where)f Fq(P)25 b(S)88 b
+ Fx(stands)77 b(for)g(the)g(partial)f(sc)-5 b(hedule,)0
+ 6302 y Fq(P)25 b(S)10 b(P)109 b Fx(means)82 b(the)h(predecessors)f(in)g
+ (the)h(partial)f(sc)-5 b(hedule,)87 b(and)c Fq(P)25 b(S)10
+ b(S)95 b Fx(is)83 b(the)f(successors)g(in)h(the)f(partial)0
+ 6667 y(sc)-5 b(hedule.)78 b(Eac)-5 b(h)57 b(instruction)f(is)h(sc)-5
+ b(heduled)56 b(from)h(a)g(start-cycle)f(to)h(an)h(end-cycle,)e(whic)-5
+ b(h)57 b(creates)f(a)i(windo)-5 b(w)0 7032 y(of)52 b(time)e(that)i(the)
+ f(instruction)f(can)i(b)5 b(e)52 b(legally)e(sc)-5 b(heduled.)76
+ b(The)53 b(start)e(and)h(end)g(cycles)e(are)i(calculated)f(based)0
+ 7398 y(up)5 b(on)53 b(what)h(is)f(already)f(in)h(the)g(partial)f(sc)-5
+ b(hedule.)77 b(The)54 b(sc)-5 b(hedule)52 b(is)g(scanned)h(forw)-5
+ b(ards)53 b(\(if)g(the)g(start-cycle)e(is)0 7763 y(earlier)f(than)h
+ (the)f(end-cycle\))f(or)i(bac)-5 b(kw)g(ards)51 b(\(if)f(the)g
+ (start-cycle)f(is)i(later)f(than)g(the)h(end-cycle\).)75
+ b(Instructions)0 8129 y(are)61 b(sc)-5 b(heduled)59 b(according)g(to)i
+ (the)f(follo)-5 b(wing)58 b(rules:)273 8610 y Fr(\017)91
+ b Fx(F)-15 b(or)44 b(instructions)e(that)i(ha)-5 b(v)g(e)43
+ b(no)i(successors)e(or)h(predecessors)f(in)h(the)g(partial)f(sc)-5
+ b(hedule,)46 b(the)e(instruction)455 8975 y(is)59 b(sc)-5
+ b(heduled)60 b(from)f Fp(est)-12 b(ar)g(t)62 b Fx(un)-5
+ b(til)60 b Fp(est)-12 b(ar)g(t)62 b Fx(+)f Fq(I)14 b(I)g
+ Fr(\000)61 b Fx(1,)f(where)h Fp(est)-12 b(ar)g(t)62 b
+ Fx(=)f Fq(AS)10 b(AP)6324 9002 y Fh(u)6415 8975 y Fx(.)273
+ 9462 y Fr(\017)91 b Fx(If)67 b(the)i(instruction)d(only)i(has)h
+ (predecessors)e(in)h(the)g(partial)g(sc)-5 b(hedule,)69
+ b(the)f(instruction)e(is)i(sc)-5 b(heduled)455 9828 y(from)59
+ b Fp(est)-12 b(ar)g(t)62 b Fx(un)-5 b(til)60 b Fp(est)-12
+ b(ar)g(t)62 b Fx(+)f Fq(I)14 b(I)g Fr(\000)61 b Fx(1,)f(where)h
+ Fp(est)-12 b(ar)g(t)62 b Fx(=)f Fq(max)5167 9865 y Fh(v)5
+ b Fg(2)p Fh(P)20 b(S)7 b(P)20 b Fo(\()p Fh(u)p Fo(\))5845
+ 9828 y Fx(\()p Fq(t)5982 9855 y Fh(v)6124 9828 y Fx(+)p
+ Fq(\025)6371 9855 y Fh(v)6514 9828 y Fr(\000)p Fq(\016)6736
+ 9855 y Fh(v)5 b(;u)6999 9828 y Fr(\003)p Fq(I)14 b(I)g
+ Fx(\).)273 10315 y Fr(\017)91 b Fx(If)49 b(the)h(instruction)e(only)i
+ (has)g(successors)f(in)h(the)f(partial)h(sc)-5 b(hedule,)50
+ b(the)g(instruction)e(is)i(sc)-5 b(heduled)49 b(from)455
+ 10680 y Fp(lst)-12 b(ar)g(t)61 b Fx(un)-5 b(til)60 b
+ Fp(lst)-12 b(ar)g(t)62 b Fr(\000)f Fq(I)14 b(I)g Fx(+)61
+ b(1,)f(where)h Fp(lst)-12 b(ar)g(t)62 b Fx(=)f Fq(min)4685
+ 10717 y Fh(v)5 b Fg(2)p Fh(P)20 b(S)7 b(S)g Fo(\()p Fh(u)p
+ Fo(\))5347 10680 y Fx(\()p Fq(t)5484 10707 y Fh(v)5626
+ 10680 y Fr(\000)p Fq(\025)5873 10707 y Fh(u)6024 10680
+ y Fr(\000)p Fq(\016)6246 10707 y Fh(u;v)6510 10680 y
+ Fr(\003)p Fq(I)14 b(I)g Fx(\).)3809 11136 y(40)p eop
+ end
+ %%Page: 41 48
+ TeXDict begin 41 47 bop 273 183 a Fr(\017)91 b Fx(F)-15
+ b(or)74 b(instructions)e(that)i(ha)-5 b(v)g(e)74 b(b)5
+ b(oth)75 b(successors)e(and)h(predecessors)g(\(whic)-5
+ b(h)74 b(only)g(happ)5 b(ens)74 b(once)g(p)5 b(er)455
+ 548 y(recurrence\),)71 b(the)f(instruction)f(is)g(sc)-5
+ b(heduled)70 b(from)f Fp(est)-12 b(ar)g(t)72 b Fx(un)-5
+ b(til)69 b(min\()p Fp(lst)-12 b(ar)g(t)p Fx(,)72 b Fp(est)-12
+ b(ar)g(t)72 b Fx(+)p Fq(I)14 b(I)85 b Fr(\000)p Fx(1\).)455
+ 913 y Fp(est)-12 b(ar)g(t)62 b Fx(and)e Fp(lst)-12 b(ar)g(t)62
+ b Fx(are)e(de\014ned)h(the)f(same)f(as)i(the)f(previous)g(t)-5
+ b(w)g(o)60 b(situations.)282 1448 y(If)46 b(no)h(free)f(slot)f(exists)g
+ (for)h(an)h(instruction,)g(the)f(en)-5 b(tire)46 b(sc)-5
+ b(hedule)45 b(is)h(cleared)f(and)i(I)5 b(I)46 b(is)g(increased.)74
+ b(Sc)-5 b(hedul-)0 1814 y(ing)50 b(resumes)g(and)h(this)f(pattern)g
+ (rep)5 b(eats)50 b(un)-5 b(til)50 b(a)h(sc)-5 b(hedule)49
+ b(is)i(found)f(or)h(the)g(maxim)-5 b(um)48 b(I)5 b(I)51
+ b(has)f(b)5 b(een)51 b(reac)-5 b(hed.)0 2179 y(In)60
+ b(our)h(implemen)-5 b(tation)57 b(maxim)-5 b(um)58 b(I)5
+ b(I)60 b(is)g(set)g(to)g(the)g(total)g(latency)f(of)h(the)g(original)f
+ (lo)5 b(op.)p 1937 2410 3876 7 v 1934 2593 7 183 v 2036
+ 2538 a Fs(Cycle)p 2504 2593 V 2537 2593 V 501 w(Issue1)p
+ 3411 2593 V 467 w(Issue2)p 4286 2593 V 510 w(Issue3)p
+ 5202 2593 V 199 w(Issue4)p 5809 2593 V 1937 2600 3876
+ 7 v 1934 2782 7 183 v 2036 2727 a(0)p 2504 2782 V 2537
+ 2782 V 604 w(sethi\(n2\))p 3411 2782 V 275 w(sethi\(n6\))p
+ 4286 2782 V 5202 2782 V 5809 2782 V 1937 2789 3876 7
+ v 1934 2972 7 183 v 2036 2917 a(1)p 2504 2972 V 2537
+ 2972 V 604 w(sethi\(n1\))p 3411 2972 V 455 w(or\(n5\))p
+ 4286 2972 V 5202 2972 V 5809 2972 V 1937 2978 3876 7
+ v 1934 3161 7 183 v 2036 3106 a(2)p 2504 3161 V 2537
+ 3161 V 784 w(or\(n8\))p 3411 3161 V 288 w(sllx\(n11\))p
+ 4286 3161 V 5202 3161 V 5809 3161 V 1937 3167 3876 7
+ v 1934 3350 7 183 v 2036 3295 a(3)p 2504 3350 V 2537
+ 3350 V 673 w(add\(n9\))p 3411 3350 V 379 w(or\(n15\))p
+ 4286 3350 V 5202 3350 V 5809 3350 V 1937 3357 3876 7
+ v 1934 3539 7 183 v 2036 3485 a(4)p 2504 3539 V 2537
+ 3539 V 680 w(srl\(n16\))p 3411 3539 V 378 w(or\(n17\))p
+ 4286 3539 V 5202 3539 V 5809 3539 V 1937 3546 3876 7
+ v 1934 3729 7 183 v 2036 3674 a(5)p 2504 3729 V 2537
+ 3729 V 698 w(sll\(n18\))p 3411 3729 V 266 w(add\(n21\))p
+ 4286 3729 V 5202 3729 V 5809 3729 V 1937 3735 3876 7
+ v 1934 3918 7 183 v 2036 3863 a(6)p 2504 3918 V 2537
+ 3918 V 716 w(ld\(n25\))p 3411 3918 V 4286 3918 V 5202
+ 3918 V 5809 3918 V 1937 3925 3876 7 v 1934 4107 7 183
+ v 2036 4053 a(7)p 2504 4107 V 2537 4107 V 3411 4107 V
+ 4286 4107 V 5202 4107 V 5809 4107 V 1937 4114 3876 7
+ v 1934 4297 7 183 v 2036 4242 a(8)p 2504 4297 V 2537
+ 4297 V 3411 4297 V 4286 4297 V 5202 4297 V 5809 4297
+ V 1937 4303 3876 7 v 1934 4486 7 183 v 2036 4431 a(9)p
+ 2504 4486 V 2537 4486 V 698 w(sll\(n26\))p 3411 4486
+ V 4286 4486 V 5202 4486 V 5809 4486 V 1937 4493 3876
+ 7 v 1934 4675 7 183 v 2036 4620 a(10)p 2504 4675 V 2537
+ 4675 V 450 w(sethi\(n14\))p 3411 4675 V 198 w(sethi\(n24\))p
+ 4286 4675 V 5202 4675 V 5809 4675 V 1937 4682 3876 7
+ v 1934 4864 7 183 v 2036 4810 a(11)p 2504 4864 V 2537
+ 4864 V 527 w(sethi\(n5\))p 3411 4864 V 378 w(or\(n20\))p
+ 4286 4864 V 5202 4864 V 5809 4864 V 1937 4871 3876 7
+ v 1934 5054 7 183 v 2036 4999 a(12)p 2504 5054 V 2537
+ 5054 V 707 w(or\(n7\))p 3411 5054 V 288 w(sllx\(n23\))p
+ 4286 5054 V 5202 5054 V 5809 5054 V 1937 5060 3876 7
+ v 1934 5243 7 183 v 2036 5188 a(13)p 2504 5243 V 2537
+ 5243 V 450 w(sethi\(n10\))p 3411 5243 V 288 w(sllx\(n12\))p
+ 4286 5243 V 5202 5243 V 5809 5243 V 1937 5250 3876 7
+ v 1934 5432 7 183 v 2036 5378 a(14)p 2504 5432 V 2537
+ 5432 V 630 w(or\(n13\))p 3411 5432 V 378 w(or\(n27\))p
+ 4286 5432 V 5202 5432 V 5809 5432 V 1937 5439 3876 7
+ v 1934 5622 7 183 v 2036 5567 a(15)p 2504 5622 V 2537
+ 5622 V 630 w(or\(n19\))p 3411 5622 V 378 w(or\(n29\))p
+ 4286 5622 V 5202 5622 V 5809 5622 V 1937 5628 3876 7
+ v 1934 5811 7 183 v 2036 5756 a(16)p 2504 5811 V 2537
+ 5811 V 639 w(ld\(n22\))p 3411 5811 V 267 w(add\(n32\))p
+ 4286 5811 V 5202 5811 V 5809 5811 V 1937 5818 3876 7
+ v 1937 5851 V 1934 6033 7 183 v 2036 5979 a(17)p 2504
+ 6033 V 2537 6033 V 3411 6033 V 4286 6033 V 5202 6033
+ V 5809 6033 V 1937 6040 3876 7 v 1934 6223 7 183 v 2036
+ 6168 a(18)p 2504 6223 V 2537 6223 V 3411 6223 V 4286
+ 6223 V 5202 6223 V 5809 6223 V 1937 6229 3876 7 v 1934
+ 6412 7 183 v 2036 6357 a(19)p 2504 6412 V 2537 6412 V
+ 3411 6412 V 4286 6412 V 2199 w(fm)l(uls\(n34\))p 5202
+ 6412 V 5809 6412 V 1937 6419 3876 7 v 1934 6601 7 183
+ v 2036 6546 a(20)p 2504 6601 V 2537 6601 V 3411 6601
+ V 4286 6601 V 5202 6601 V 5809 6601 V 1937 6608 3876
+ 7 v 1934 6791 7 183 v 2036 6736 a(21)p 2504 6791 V 2537
+ 6791 V 3411 6791 V 4286 6791 V 5202 6791 V 5809 6791
+ V 1937 6797 3876 7 v 1934 6980 7 183 v 2036 6925 a(22)p
+ 2504 6980 V 2537 6980 V 3411 6980 V 4286 6980 V 5202
+ 6980 V 5809 6980 V 1937 6987 3876 7 v 1934 7169 7 183
+ v 2036 7114 a(23)p 2504 7169 V 2537 7169 V 3411 7169
+ V 1521 w(st\(n35\))p 4286 7169 V 5202 7169 V 5809 7169
+ V 1937 7176 3876 7 v 1394 7568 a Fx(T)-15 b(able)60 b(4.3:)80
+ b(Sc)-5 b(hedule)60 b(for)g(a)g(Single)g(Iteration)f(of)h(the)g(Lo)5
+ b(op)60 b(Example)282 8122 y(Using)76 b(this)f(sc)-5
+ b(hedule,)78 b(the)d(k)-5 b(ernel)76 b(is)f(constructed)g(b)-5
+ b(y)76 b(taking)f(all)g(instructions)f(sc)-5 b(heduled)74
+ b(at)i(a)g(cycle)0 8488 y(greater)50 b(than)h(I)5 b(I,)49
+ b(\014nds)i(what)f(stage)g(they)g(are)h(from,)g(and)g(what)g(cycle)e
+ (in)h(the)h(k)-5 b(ernel)50 b(it)f(should)h(b)5 b(e)51
+ b(sc)-5 b(heduled.)0 8853 y(The)66 b(stage)f(is)g(found)g(b)-5
+ b(y)66 b(dividing)e(the)h(cycle)g(b)-5 b(y)66 b(I)5 b(I)65
+ b(\(and)g(rounding)h(do)-5 b(wn\).)96 b(The)66 b(k)-5
+ b(ernel)65 b(cycle)f(is)h(equal)g(to)0 9218 y(the)59
+ b(instruction's)e(sc)-5 b(heduled)59 b(cycle)g Fu(mo)5
+ b(dulo)58 b Fx(I)5 b(I.)59 b(Additionally)-15 b(,)57
+ b(the)i(instructions)f(related)h(to)g(the)h(induction)0
+ 9584 y(v)-10 b(ariable)53 b(and)h(branc)-5 b(h)54 b(\(not)f(considered)
+ g(during)h(previous)f(phases\))g(are)h(reinserted)f(at)h(their)f(prop)5
+ b(er)55 b(lo)5 b(cation)0 9949 y(\(preserving)61 b(dep)5
+ b(endencies)61 b(and)h(placing)g(the)g(branc)-5 b(h)62
+ b(at)g(the)g(end\))g(in)g(the)g(k)-5 b(ernel.)85 b(During)62
+ b(the)g(sc)-5 b(heduling)0 10315 y(pro)5 b(cess)53 b(k)-5
+ b(ernel)53 b(con\015icts,)g(resource)g(con\015icts)f(with)h
+ (instructions)e(from)i(another)g(stage,w)-5 b(ere)52
+ b(c)-5 b(hec)g(k)g(ed)53 b(b)5 b(efore)0 10680 y(an)61
+ b(instruction)d(w)-5 b(as)61 b(assigned)e(an)h(issue)g(slot.)3809
+ 11136 y(41)p eop end
+ %%Page: 42 49
+ TeXDict begin 42 48 bop 282 183 a Fx(T)-15 b(able)75
+ b(4.3)f(sho)-5 b(ws)74 b(the)h(sc)-5 b(hedule)74 b(for)g(a)h(single)e
+ (iteration)h(and)h(the)f(k)-5 b(ernel)74 b(for)h(the)f(lo)5
+ b(op)75 b(w)-5 b(e)75 b(ha)-5 b(v)g(e)74 b(b)5 b(een)0
+ 548 y(using)55 b(as)g(an)g(example)f(throughout)h(the)h(c)-5
+ b(hapter.)78 b(The)55 b(SP)-15 b(AR)-5 b(C)56 b(I)5 b(I)g(Ii)54
+ b(arc)-5 b(hitecture)54 b(can)h(issue)g(4)g(instructions)0
+ 913 y(p)5 b(er)60 b(cycle.)79 b(The)59 b(com)-5 b(bination)58
+ b(of)h(instructions)f(that)h(can)g(b)5 b(e)60 b(issued)e(dep)5
+ b(ends)59 b(on)h(what)f(resources)g(they)g(use)0 1279
+ y(during)73 b(eac)-5 b(h)73 b(stage)f(of)h(the)g(pip)5
+ b(eline.)117 b(F)-15 b(or)73 b(simplicit)-5 b(y)-15 b(,)73
+ b(the)g(sc)-5 b(hedule)72 b(in)h(T)-15 b(able)73 b(4.3)f(only)h(sho)-5
+ b(ws)73 b(the)g(issue)0 1644 y(slots,)48 b(but)e(the)g(sc)-5
+ b(heduling)45 b(algorithm)g(c)-5 b(hec)g(ks)46 b(b)5
+ b(oth)46 b(that)g(there)g(is)g(an)h(a)-5 b(v)-10 b(ailable)44
+ b(issue)i(slot,)i(and)e(all)g(resources)0 2010 y(are)61
+ b(a)-5 b(v)-10 b(ailable.)282 2375 y(In)66 b(the)f(sc)-5
+ b(hedule,)66 b(all)f(instructions)e(b)5 b(efore)66 b(cycle)f(17)g(b)5
+ b(elong)66 b(to)f(stage)g(0)h(\(the)f(curren)-5 b(t)66
+ b(iteration)e(of)h(the)0 2740 y(lo)5 b(op\),)82 b(while)c(all)g
+ (instructions)f(after)h(b)5 b(elong)78 b(to)h(stage)f(1.)135
+ b(The)79 b(sc)-5 b(heduling)78 b(algorithm)f(has)h(managed)g(to)0
+ 3106 y(generate)54 b(a)h(sc)-5 b(hedule)54 b(of)h(length)f(17,)i(whic)
+ -5 b(h)54 b(w)-5 b(as)55 b(our)h(MI)5 b(I.)53 b(This)i(is)f(an)i
+ (optimal)d(sc)-5 b(hedule.)77 b(The)55 b(instructions)0
+ 3471 y(ha)-5 b(v)g(e)73 b(b)5 b(een)73 b(sc)-5 b(heduled)72
+ b(suc)-5 b(h)73 b(that)g(man)-5 b(y)73 b(of)g(the)g(single)f(cycle)g
+ (instructions)f(can)j(b)5 b(e)73 b(o)-5 b(v)g(erlapp)5
+ b(ed)72 b(with)h(the)0 3836 y(\015oating)82 b(p)5 b(oin)-5
+ b(t)82 b(m)-5 b(ultiply)81 b(\(n34\))h(whic)-5 b(h)83
+ b(tak)-5 b(es)82 b(4)h(cycles.)146 b(T)-15 b(able)82
+ b(4.4)g(sho)-5 b(ws)83 b(the)g(k)-5 b(ernel)82 b(for)h(the)f(mo)5
+ b(dulo)0 4202 y(sc)-5 b(heduled)76 b(lo)5 b(op.)128 b(The)77
+ b(n)-5 b(um)g(b)5 b(er)77 b(enclosed)f(in)g(brac)-5 b(k)g(ets)76
+ b(indicates)f(whic)-5 b(h)77 b(stage)f(the)g(instruction)f(is)h(from.)0
+ 4567 y(The)68 b(fm)-5 b(uls)67 b(\(n34\))g(instruction)f(is)i(from)f
+ (stage)g(1,)j(whic)-5 b(h)68 b(means)f(that)g(the)h(instruction)e(is)h
+ (from)h(a)g(previous)0 4933 y(iteration.)p 1856 5138
+ 4038 7 v 1853 5321 7 183 v 1955 5266 a Fs(Cycle)p 2423
+ 5321 V 2456 5321 V 501 w(Issue1)p 3330 5321 V 467 w(Issue2)p
+ 4205 5321 V 672 w(Issue3)p 5284 5321 V 199 w(Issue4)p
+ 5890 5321 V 1856 5328 4038 7 v 1853 5510 7 183 v 1955
+ 5456 a(0)p 2423 5510 V 2456 5510 V 604 w(sethi\(n2\))p
+ 3330 5510 V 275 w(sethi\(n6\))p 4205 5510 V 5284 5510
+ V 5890 5510 V 1856 5517 4038 7 v 1853 5700 7 183 v 1955
+ 5645 a(1)p 2423 5700 V 2456 5700 V 604 w(sethi\(n1\))p
+ 3330 5700 V 455 w(or\(n5\))p 4205 5700 V 5284 5700 V
+ 5890 5700 V 1856 5706 4038 7 v 1853 5889 7 183 v 1955
+ 5834 a(2)p 2423 5889 V 2456 5889 V 784 w(or\(n8\))p 3330
+ 5889 V 288 w(sllx\(n11\))p 4205 5889 V 197 w(fm)l(uls\(n34\)[1])p
+ 5284 5889 V 5890 5889 V 1856 5896 4038 7 v 1853 6078
+ 7 183 v 1955 6023 a(3)p 2423 6078 V 2456 6078 V 673 w(add\(n9\))p
+ 3330 6078 V 379 w(or\(n15\))p 4205 6078 V 5284 6078 V
+ 5890 6078 V 1856 6085 4038 7 v 1853 6268 7 183 v 1955
+ 6213 a(4)p 2423 6268 V 2456 6268 V 680 w(srl\(n16\))p
+ 3330 6268 V 378 w(or\(n17\))p 4205 6268 V 5284 6268 V
+ 5890 6268 V 1856 6274 4038 7 v 1853 6457 7 183 v 1955
+ 6402 a(5)p 2423 6457 V 2456 6457 V 698 w(sll\(n18\))p
+ 3330 6457 V 266 w(add\(n21\))p 4205 6457 V 5284 6457
+ V 5890 6457 V 1856 6463 4038 7 v 1853 6646 7 183 v 1955
+ 6591 a(6)p 2423 6646 V 2456 6646 V 716 w(ld\(n25\))p
+ 3330 6646 V 232 w(st\(n35\)[1])p 4205 6646 V 5284 6646
+ V 5890 6646 V 1856 6653 4038 7 v 1853 6835 7 183 v 1955
+ 6781 a(7)p 2423 6835 V 2456 6835 V 3330 6835 V 4205 6835
+ V 5284 6835 V 5890 6835 V 1856 6842 4038 7 v 1853 7025
+ 7 183 v 1955 6970 a(8)p 2423 7025 V 2456 7025 V 3330
+ 7025 V 4205 7025 V 5284 7025 V 5890 7025 V 1856 7031
+ 4038 7 v 1853 7214 7 183 v 1955 7159 a(9)p 2423 7214
+ V 2456 7214 V 698 w(sll\(n26\))p 3330 7214 V 4205 7214
+ V 5284 7214 V 5890 7214 V 1856 7221 4038 7 v 1853 7403
+ 7 183 v 1955 7348 a(10)p 2423 7403 V 2456 7403 V 450
+ w(sethi\(n14\))p 3330 7403 V 198 w(sethi\(n24\))p 4205
+ 7403 V 5284 7403 V 5890 7403 V 1856 7410 4038 7 v 1853
+ 7593 7 183 v 1955 7538 a(11)p 2423 7593 V 2456 7593 V
+ 527 w(sethi\(n5\))p 3330 7593 V 378 w(or\(n20\))p 4205
+ 7593 V 5284 7593 V 5890 7593 V 1856 7599 4038 7 v 1853
+ 7782 7 183 v 1955 7727 a(12)p 2423 7782 V 2456 7782 V
+ 707 w(or\(n7\))p 3330 7782 V 288 w(sllx\(n23\))p 4205
+ 7782 V 5284 7782 V 5890 7782 V 1856 7788 4038 7 v 1853
+ 7971 7 183 v 1955 7916 a(13)p 2423 7971 V 2456 7971 V
+ 450 w(sethi\(n10\))p 3330 7971 V 288 w(sllx\(n12\))p
+ 4205 7971 V 5284 7971 V 5890 7971 V 1856 7978 4038 7
+ v 1853 8160 7 183 v 1955 8106 a(14)p 2423 8160 V 2456
+ 8160 V 630 w(or\(n13\))p 3330 8160 V 378 w(or\(n27\))p
+ 4205 8160 V 5284 8160 V 5890 8160 V 1856 8167 4038 7
+ v 1853 8350 7 183 v 1955 8295 a(15)p 2423 8350 V 2456
+ 8350 V 630 w(or\(n19\))p 3330 8350 V 378 w(or\(n29\))p
+ 4205 8350 V 5284 8350 V 5890 8350 V 1856 8356 4038 7
+ v 1853 8539 7 183 v 1955 8484 a(16)p 2423 8539 V 2456
+ 8539 V 639 w(ld\(n22\))p 3330 8539 V 267 w(add\(n32\))p
+ 4205 8539 V 5284 8539 V 5890 8539 V 1856 8546 4038 7
+ v 2458 8938 a Fx(T)-15 b(able)60 b(4.4:)79 b(Kernel)61
+ b(for)f(Lo)5 b(op)60 b(Example)3809 11136 y(42)p eop
+ end
+ %%Page: 43 50
+ TeXDict begin 43 49 bop 0 183 a Ft(4.7)270 b(Lo)7 b(op)91
+ b(Reconstruction)0 728 y Fx(The)73 b(lo)5 b(op)73 b(reconstruction)e
+ (phase)h(is)h(resp)5 b(onsible)71 b(for)h(generating)g(the)h
+ (prologues,)h(epilogues,)g(k)-5 b(ernel,)75 b(and)0 1093
+ y(\014xing)50 b(the)f(con)-5 b(trol)49 b(\015o)-5 b(w)51
+ b(of)e(the)h(original)e(program)i(to)g(branc)-5 b(h)50
+ b(to)g(the)f(mo)5 b(dulo)49 b(sc)-5 b(heduled)49 b(lo)5
+ b(op.)76 b(Figure)100 b(4.11)0 1459 y(sho)-5 b(ws)60
+ b(the)g(lo)5 b(op)60 b(reconstruction)f(algorithm.)282
+ 1824 y(The)72 b(k)-5 b(ernel)71 b(constructed)f(b)-5
+ b(y)72 b(the)f(sc)-5 b(heduling)70 b(phase)h(consists)e(of)i
+ (instructions)f(from)h(m)-5 b(ultiple)69 b(stages.)0
+ 2190 y(Instructions)55 b(from)g(a)i(stage)e(greater)h(than)h(zero)f
+ (are)g(a)h(part)f(of)g(a)h(previous)e(iteration.)78 b(Prior)56
+ b(to)g(en)-5 b(tering)55 b(the)0 2555 y(k)-5 b(ernel,)47
+ b(the)e(previous)g(iterations)e(m)-5 b(ust)45 b(b)5 b(e)45
+ b(initiated)e(in)i(the)g(prologues.)74 b(Lines)44 b(6-14)h(in)g(Figure)
+ g(4.11)f(illustrate)0 2920 y(ho)-5 b(w)52 b(the)e(prologue)h(is)g
+ (constructed.)76 b(There)51 b(are)g(as)g(man)-5 b(y)51
+ b(basic)f(blo)5 b(c)-5 b(ks)51 b(in)g(the)f(prologue)h(as)g(there)g
+ (are)g(stages)0 3286 y(in)68 b(the)h(k)-5 b(ernel,)70
+ b(min)-5 b(us)67 b(one.)105 b(F)-15 b(or)69 b(example,)g(our)g(sample)e
+ (lo)5 b(op)69 b(k)-5 b(ernel)68 b(\(T)-15 b(able)68 b(4.4\))g(has)g(t)
+ -5 b(w)g(o)69 b(stages,)g(and)g(a)0 3651 y(max)55 b(stage)f(of)h(one.)
+ 78 b(This)55 b(results)f(in)h(a)g(prologue)g(with)f(one)i(basic)e(blo)5
+ b(c)-5 b(k,)55 b(whic)-5 b(h)55 b(consists)e(of)i(all)f(instructions)0
+ 4016 y(from)h(the)g(original)f(basic)h(blo)5 b(c)-5 b(k)55
+ b(\(in)g(original)f(execution)g(order\))i(that)f(are)g(from)g(stage)g
+ (0)h(in)f(the)g(k)-5 b(ernel.)78 b(If)55 b(an)0 4382
+ y(instruction's)c(op)5 b(erand)54 b(is)f(used)h(in)f(an)h(instruction)e
+ (from)h(a)h(greater)f(stage,)h(a)g(cop)-5 b(y)53 b(of)h(that)f(v)-10
+ b(alue)53 b(is)g(made)g(to)0 4747 y(sa)-5 b(v)g(e)60
+ b(the)g(v)-10 b(alue.)80 b(Figure)60 b(4.12)g(sho)-5
+ b(ws)60 b(the)g(generated)g(prologue)g(for)h(our)f(sample)g(lo)5
+ b(op.)80 b(Notice)59 b(the)i(extra)f Fu(or)0 5113 y Fx(and)h
+ Fu(fmo)-5 b(vs)59 b Fx(instructions)f(that)i(sa)-5 b(v)g(e)60
+ b(v)-10 b(alues)59 b(that)h(are)h(used)f(in)g(the)g(k)-5
+ b(ernel,)60 b(these)f(are)i(the)f(inserted)f(copies.)282
+ 5478 y(The)74 b(epilogue)e(exists)h(to)g(\014nish)g(iterations)f(that)h
+ (w)-5 b(ere)74 b(initiated)d(in)i(either)g(a)h(prologue)f(or)h(the)f(k)
+ -5 b(ernel,)0 5843 y(but)60 b(ha)-5 b(v)g(e)60 b(not)g(completed.)78
+ b(Lines)59 b(18-23)g(sho)-5 b(w)61 b(the)e(steps)h(to)f(create)h(the)g
+ (epilogue.)78 b(F)-15 b(or)60 b(eac)-5 b(h)60 b(stage)f(greater)0
+ 6209 y(than)h(zero)h(in)f(the)g(k)-5 b(ernel,)59 b(there)h(is)g(a)h
+ (basic)e(blo)5 b(c)-5 b(k)60 b(in)g(the)g(epilogue.)282
+ 6574 y(The)44 b(k)-5 b(ernel)43 b(construction)g(is)g(detailed)f(in)h
+ (Lines)g(24-29)g(in)g(Figure)g(4.11.)74 b(F)-15 b(or)44
+ b(an)-5 b(y)43 b(instruction)f(that)i(de\014nes)0 6939
+ y(a)69 b(v)-10 b(alue)69 b(that)f(is)h(used)g(b)-5 b(y)69
+ b(an)h(instruction)d(from)i(a)g(later)f(stage,)i(that)f(v)-10
+ b(alue)69 b(m)-5 b(ust)68 b(b)5 b(e)69 b(sa)-5 b(v)g(ed.)106
+ b(Instructions)0 7305 y(from)56 b(stages)g(greater)h(than)g(zero)g(are)
+ g(then)g(up)5 b(dated)57 b(to)g(use)g(the)f(correct)h(v)-5
+ b(ersion)57 b(of)f(the)h(v)-10 b(alue.)78 b(Figure)57
+ b(4.13)0 7670 y(sho)-5 b(ws)60 b(the)g(k)-5 b(ernel)60
+ b(for)g(our)h(example)e(lo)5 b(op.)282 8036 y(Finally)-15
+ b(,)61 b(the)h(branc)-5 b(hes)62 b(need)g(to)g(b)5 b(e)63
+ b(corrected)f(to)g(branc)-5 b(h)63 b(to)f(the)g(prop)5
+ b(er)63 b(basic)e(blo)5 b(c)-5 b(k.)86 b(F)-15 b(or)62
+ b(eac)-5 b(h)62 b(basic)0 8401 y(blo)5 b(c)-5 b(k)60
+ b(in)g(the)g(prologue,)f(the)h(branc)-5 b(h)60 b(m)-5
+ b(ust)60 b(b)5 b(e)60 b(up)5 b(dated)60 b(to)g(either)g(branc)-5
+ b(h)60 b(to)g(the)g(next)g(basic)g(blo)5 b(c)-5 b(k)59
+ b(in)h(the)0 8766 y(prologue)k(\(or)g(k)-5 b(ernel)64
+ b(if)f(its)g(the)h(last)g(basic)f(blo)5 b(c)-5 b(k\))63
+ b(or)i(to)f(the)g(corresp)5 b(onding)63 b(basic)h(blo)5
+ b(c)-5 b(k)63 b(in)h(the)g(epilogue.)0 9132 y(The)75
+ b(k)-5 b(ernel)73 b(branc)-5 b(h)75 b(is)e(up)5 b(dated)74
+ b(to)g(branc)-5 b(h)75 b(to)f(itself)e(or)j(to)f(the)g(\014rst)g
+ (epilogue.)120 b(Epilogue)73 b(branc)-5 b(hes)74 b(are)0
+ 9497 y(c)-5 b(hanged)59 b(to)g(unconditional)e(branc)-5
+ b(hes)58 b(to)h(the)g(next)g(basic)f(blo)5 b(c)-5 b(k)58
+ b(in)h(the)g(epilogue)f(or)h(the)g(original)e(lo)5 b(op)59
+ b(exit)0 9862 y(p)5 b(oin)-5 b(t.)108 b(Lastly)-15 b(,)71
+ b(the)f(branc)-5 b(h)70 b(to)g(the)g(original)e(lo)5
+ b(op)70 b(in)g(our)g(program)g(m)-5 b(ust)70 b(b)5 b(e)70
+ b(up)5 b(dated)69 b(to)h(branc)-5 b(h)71 b(to)e(the)0
+ 10228 y(prologue.)282 10593 y(Once)75 b(the)g(prologue,)i(epilogue,)g
+ (and)e(k)-5 b(ernel)74 b(ha)-5 b(v)g(e)75 b(b)5 b(een)75
+ b(generated,)i(the)e(lo)5 b(op)74 b(has)h(b)5 b(een)75
+ b(successfully)3809 11136 y(43)p eop end
+ %%Page: 44 51
+ TeXDict begin 44 50 bop 1486 1302 a Fs(1)196 b Fm(maxS)8
+ b(tag)d(e)46 b Fs(=)52 b(maxim)l(um)e(stage)h(in)g(k)l(ernel)1486
+ 1484 y(2)196 b Fm(P)21 b(r)t(ol)r(og)5 b(ue)46 b Fs(=)52
+ b(list)e(of)h(prologue)g(basic)g(blo)t(c)l(ks)1486 1667
+ y(3)196 b Fm(E)9 b(pil)r(og)c(ue)44 b Fs(=)52 b(list)e(of)h(epilogue)g
+ (basic)g(blo)t(c)l(ks)1486 1849 y(4)196 b Fm(k)t(er)t(nel)r(B)7
+ b(B)53 b Fs(=)f(new)f(k)l(ernel)h(basic)f(blo)t(c)l(k)1486
+ 2032 y(5)1486 2215 y(6)196 b(for\()p Fm(i)42 b Fs(=)h(0;)51
+ b Fm(i)42 b(<)p Fs(=)i Fm(maxS)8 b(tag)d(e)p Fs(;)53
+ b(++)p Fm(i)p Fs(\))270 b(//Create)50 b(Prologue)1486
+ 2397 y(7)358 b Fm(B)7 b(B)51 b Fs(=)h(new)g(basic)f(blo)t(c)l(k)1486
+ 2580 y(8)358 b(for\()p Fm(j)51 b Fs(=)43 b Fm(i)p Fs(;)51
+ b Fm(j)g(>)p Fs(=)43 b(0;)51 b Fn(\000)34 b(\000)h Fm(j)9
+ b Fs(\))1486 2763 y(9)521 b Fn(8)p Fm(n)51 b Fs(instructions)f(in)h
+ (original)f(basic)h(blo)t(c)l(k)1486 2945 y(10)606 b(if)51
+ b(\()p Fm(n)42 b Fn(2)51 b Fs(k)l(ernel)h(at)f(stage)f
+ Fm(j)9 b Fs(\))1486 3128 y(11)768 b(BB.add\(n\))1486
+ 3311 y(12)g(if)51 b(\()p Fm(n)f Fs(de\014nes)j(v)-9 b(alue)51
+ b(used)h(in)f(k)l(ernel)h(at)f(later)g(stage\))1486 3493
+ y(13)930 b(BB.add\(cop)l(y)51 b(v)-9 b(alue)52 b(instruction\))1486
+ 3676 y(14)281 b(Prologue.add\(BB\))1486 3859 y(15)1486
+ 4041 y(16)119 b(for\()p Fm(i)42 b Fs(=)h Fm(maxS)8 b(tag)d(e)37
+ b Fn(\000)e Fs(1;)51 b Fm(i)42 b(>)p Fs(=)h(0;)51 b({)p
+ Fm(i)p Fs(\))166 b(//Create)50 b(Epilogue)1486 4224 y(17)281
+ b Fm(B)7 b(B)51 b Fs(=)h(new)g(basic)f(blo)t(c)l(k)1486
+ 4407 y(18)281 b(for\()p Fm(j)51 b Fs(=)43 b Fm(maxS)8
+ b(tag)d(e)p Fs(;)54 b Fm(j)d(>)43 b(i)p Fs(;)50 b({)p
+ Fm(j)9 b Fs(\))1486 4589 y(19)444 b Fn(8)p Fm(n)51 b
+ Fs(instructions)f(in)h(original)f(basic)h(blo)t(c)l(k)1486
+ 4772 y(20)606 b(if)51 b(\()p Fm(n)42 b Fn(2)51 b Fs(k)l(ernel)h(at)f
+ (stage)f Fm(j)9 b Fs(\))1486 4954 y(21)768 b(up)t(date)52
+ b(n)g(to)e(use)i(correct)g(op)t(erand)g(v)-9 b(alues)1486
+ 5137 y(22)768 b(BB.add\(n\))1486 5320 y(23)281 b(Epilogue.add\(BB\))
+ 1486 5502 y(24)1486 5685 y(25)119 b Fn(8)p Fm(n)52 b
+ Fs(instructions)e Fn(2)h Fs(k)l(ernel)834 b(//Create)50
+ b(Kernel)1486 5868 y(26)281 b(if)51 b(\()p Fm(n)42 b
+ Fn(2)52 b Fs(k)l(ernel)g(at)e Fm(stag)5 b(e)44 b(>)g
+ Fs(0\))1486 6050 y(27)444 b(up)t(date)52 b(n)f(to)g(use)h(correct)f(op)
+ t(erand)i(v)-9 b(alues)1486 6233 y(28)281 b(if)51 b(\()p
+ Fm(n)g Fs(de\014nes)h(v)-9 b(alue)52 b(used)g(in)f(k)l(ernel)h(at)e
+ (later)h(stage\))1486 6416 y(29)444 b(BB.add\(cop)l(y)50
+ b(v)-9 b(alue)52 b(instruction\))1486 6598 y(30)1486
+ 6781 y(31)119 b Fn(8)p Fm(b)52 b Fn(2)f Fm(P)21 b(r)t(ol)r(og)5
+ b(ue)1475 b Fs(//Up)t(date)51 b(Prologue)g(Branc)l(hes)1486
+ 6964 y(32)281 b(if)51 b(\()p Fm(b)g Fs(not)g(last)f Fn(2)i
+ Fm(P)21 b(r)t(ol)r(og)5 b(ue)p Fs(\))1486 7146 y(33)444
+ b(up)t(date)52 b(branc)l(h)g(to)f(branc)l(h)h(to)e(correct)i(bb)g(in)f
+ (the)h(epilogue/prologue)1486 7329 y(34)281 b(else)1486
+ 7512 y(35)444 b(up)t(date)52 b(branc)l(h)g(to)f(branc)l(h)h(to)e(k)l
+ (ernel/epilogue)1486 7694 y(36)1486 7877 y(37)119 b Fn(8)p
+ Fm(b)52 b Fn(2)f Fm(E)9 b(pil)r(og)c(ue)1489 b Fs(//Up)t(date)51
+ b(Epilogue)g(Branc)l(hes)1486 8060 y(38)281 b(if)51 b(\()p
+ Fm(b)g Fs(not)g(last)f Fn(2)i Fm(E)9 b(pil)r(og)c(ue)p
+ Fs(\))1486 8242 y(39)444 b(c)l(hange)51 b(branc)l(h)h(to)f
+ (unconditional)g(branc)l(h)h(to)f(next)h(basic)f(blo)t(c)l(k)1486
+ 8425 y(40)281 b(else)1486 8607 y(41)444 b(c)l(hange)51
+ b(branc)l(h)h(to)f(unconditional)g(branc)l(h)h(to)f(original)f(lo)t(op)
+ h(exit)1486 8790 y(42)1486 8973 y(43)119 b(Up)t(date)53
+ b(k)l(ernel)e(branc)l(h)h(to)f(branc)l(h)h(to)f(k)l(ernel/epilogue)1486
+ 9155 y(44)119 b(Up)t(date)53 b(program's)d(branc)l(h)i(to)f(original)f
+ (lo)t(op)h(to)f(branc)l(h)i(to)f(the)h(prologue)1431
+ 9675 y Fx(Figure)60 b(4.11:)79 b(Pseudo)60 b(Co)5 b(de)61
+ b(for)f(Lo)5 b(op)60 b(Reconstruction)f(Algorithm)3809
+ 11136 y(44)p eop end
+ %%Page: 45 52
+ TeXDict begin 45 51 bop 0 183 a Fx(mo)5 b(dulo)62 b(sc)-5
+ b(heduled)62 b(and)h(the)g(Swing)g(Mo)5 b(dulo)62 b(Sc)-5
+ b(heduling)62 b(algorithm)f(has)i(completed.)86 b(SMS)63
+ b(is)f(applied)g(to)0 548 y(eac)-5 b(h)60 b(single)f(basic)h(blo)5
+ b(c)-5 b(k)60 b(lo)5 b(op)59 b(in)i(the)f(program.)3809
+ 11136 y(45)p eop end
+ %%Page: 46 53
+ TeXDict begin 46 52 bop 15 1312 a Fo(P)15 b(r)g(o)g(l)g(o)g(g)g(u)g(e)
+ 36 b(:)14 1470 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(l)t(m)14 b(\()20 b Fg(\000)10 b Fo(1)g(\))20 b(,)65
+ b(\045)26 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g(0)23 b(\))14
+ 1627 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5 b(h)t(h)t(\()o(\045)16
+ b(d)h(i)g(s)g(p)34 b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q
+ Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16
+ b(\))30 b(,)79 b(\045)32 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(a)g(9)g(0)22
+ b(\))-1 1785 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(0)g(2)g(0)g
+ (0)117 b(i)50 b(.)28 b(0)f(.)h(0)f(:)32 b(P)5 b(h)g(i)g(C)g(p)19
+ b(\))27 b(,)73 b(\045)20 b(g)7 b(0)26 b(,)73 b(\045)28
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122 b(i)48 b(.)25
+ b(0)f(.)h(0)g(\))14 1943 y Fi(s)14 b(e)g(t)g(h)g(i)67
+ b Fo(\045)5 b(h)t(h)h(\()r Fh(<)11 b Fo(c)e(p)14 b(#)t(1)7
+ b Fh(>)t Fo(\))g(,)52 b(\045)20 b(r)c(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)22
+ b(\))7 2101 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(a)g(9)g
+ (0)20 b(\))27 b(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16
+ b(d)h(i)g(s)g(p)34 b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q
+ Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16
+ b(\))31 b(,)79 b(\045)31 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g(0)25
+ b(\))14 2258 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(l)t(m)s(\()o(\045)16 b(d)h(i)g(s)g(p)34 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17
+ b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(c)g(7)g(0)29 b(\))7 2416 y Fi(o)7 b(r)58 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)20 b(\))27 b(,)74
+ b(\045)t(h)-9 b(m)h(\()r Fh(<)11 b Fo(c)e(p)k(#)t(1)7
+ b Fh(>)t Fo(\))g(,)53 b(\045)20 b(r)c(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g(0)22
+ b(\))7 2574 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g
+ (0)21 b(\))27 b(,)74 b(\045)32 b(l)20 b(o)30 b(\()20
+ b Fg(\000)10 b Fo(1)g(\))20 b(,)65 b(\045)26 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g
+ (0)30 b(\))-1 2732 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g
+ (0)122 b(i)43 b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g(0)28 b(\))e(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g(0)104 b(m)6 b(a)g(s)g(k)g(H)g(i)23
+ b(\))14 2889 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(l)t(m)g(\()r Fh(<)11 b Fo(c)e(p)14 b(#)t(1)7 b Fh(>)t
+ Fo(\))g(,)52 b(\045)20 b(r)c(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g(0)22
+ b(\))20 3047 y Fi(s)e(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g
+ (0)28 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(b)g(d)g(0)27 b(\))20 3205 y Fi(s)20 b(l)g(l)g(x)69
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g(0)25 b(\))34
+ b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(e)g
+ (0)29 b(\))7 3363 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g
+ (0)20 b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(e)g(0)28
+ b(\))e(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g(0)22
+ b(\))14 3520 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(h)t(h)t(\()o(\045)16 b(d)h(i)g(s)g(p)34 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17
+ b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g
+ (2)g(f)g(6)g(0)29 b(\))7 3678 y Fi(o)7 b(r)58 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(3)g(1)g(c)g(7)g(0)28 b(\))f(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)27 b(x)10
+ b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(d)g(0)26 b(\))g(,)74 b(\045)30
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)27 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g(0)25 b(\))19 3836 y
+ Fi(s)19 b(r)g(l)71 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83
+ b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)95 b(t)q(m)q(p)23
+ b(.)g(8)f(\))7 3993 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g
+ (0)23 b(\))k(,)74 b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g(0)30 b(\))25 4151 y
+ Fi(s)25 b(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)95
+ b(t)q(m)q(p)20 b(.)g(8)g(\))38 b(,)87 b(2)39 b(,)87 b(\045)36
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12
+ b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(5)g(0)22 b(\))7 4309 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g(0)20
+ b(\))27 b(,)74 b(\045)32 b(l)20 b(o)h(\()r Fh(<)11 b
+ Fo(c)e(p)k(#)t(1)7 b Fh(>)t Fo(\))g(,)53 b(\045)20 b(r)c(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g
+ (0)27 b(\))7 4467 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g(2)g(f)g(6)g
+ (0)28 b(\))f(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g(0)22 b(\))-1 4624 y
+ Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g(0)32
+ b(\))j(,)83 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)27 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g
+ (0)108 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)20 b(A)n(2)12 b(\))11 4782 y Fi(l)f(d)63 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g(0)30 b(\))36 b(,)82
+ b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(1)g(7)g(f)g(c)g(0)27
+ b(\))1 4940 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(1)g(7)g(f)g(c)g
+ (0)26 b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(2)g(0)29
+ b(\))20 5098 y Fi(s)20 b(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g
+ (0)25 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g
+ (0)g(6)g(4)g(0)21 b(\))14 5255 y Fi(s)14 b(e)g(t)g(h)g(i)67
+ b Fo(\045)5 b(l)t(m)s(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g(0)29 b(\))11 5413 y
+ Fi(l)11 b(d)63 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g(0)108
+ b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)38
+ b(:)21 b(A)n(2)10 b(\))27 b(,)73 b(\045)30 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(5)g
+ (0)21 b(\))26 b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)29 b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)97
+ b(t)q(m)q(p)21 b(.)g(1)g(1)g(\))1 5571 y Fi(f)q(m)q(o)q(v)q(s)52
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)96 b(t)q(m)q(p)18
+ b(.)f(1)g(1)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)15 b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(c)g
+ (0)28 b(\))25 5729 y Fi(s)d(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g
+ (0)122 b(i)44 b(.)21 b(0)g(.)g(0)g(\))42 b(,)90 b(2)42
+ b(,)90 b(\045)37 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g(0)24
+ b(\))7 5886 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g
+ (0)27 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(0)g(6)g
+ (0)22 b(\))7 6044 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g
+ (0)28 b(\))f(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(4)g(0)21
+ b(\))26 b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)22
+ b(\))-1 6202 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g
+ (0)122 b(i)44 b(.)21 b(0)g(.)g(0)g(\))42 b(,)90 b(1)42
+ b(,)90 b(\045)37 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))7 6360 y Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)20 b(\))27
+ b(,)74 b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)25 b(\))19 6517 y
+ Fi(s)19 b(r)g(l)71 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83
+ b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)109 b(i)16
+ b(n)g(d)g(v)g(a)g(r)40 b(.)c(n)14 b(e)g(x)g(t)28 b(\))-1
+ 6675 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)109
+ b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(.)d(n)14 b(e)g(x)g(t)26
+ b(\))h(,)73 b(\045)20 b(g)7 b(0)26 b(,)73 b(\045)28 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g
+ (0)g(2)g(0)g(0)117 b(i)51 b(.)27 b(0)g(.)h(0)f(:)32 b(P)5
+ b(h)g(i)g(C)g(p)21 b(\))-1 6833 y Fi(a)o(d)o(d)48 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)27 b(\))35 b(,)83
+ b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)27 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)108
+ b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)20 b(A)n(1)12 b(\))7 6991 y Fi(o)7 b(r)58 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)108 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)
+ g(l)g(o)g(b)g(a)g(l)38 b(:)21 b(A)n(1)14 b(\))36 b(,)82
+ b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(1)g(0)g(0)22
+ b(\))6 7148 y Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)108 b(i)16 b(n)g(d)g(v)g(a)g(r)40
+ b(.)d(n)14 b(e)g(x)g(t)30 b(\))k(,)82 b(5)17 b(0)g(0)33
+ b(,)81 b(\045)24 b(g)7 b(0)26 b(,)72 b(\045)31 b(c)18
+ b(c)g(r)g(e)g(g)33 b(\()f(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g(0)30 b(\))7 7306 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(0)g(6)g(0)24
+ b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)36 b(x)19 b(1)g(0)g(0)g(c)g(f)g(f)g(6)g(e)g
+ (0)30 b(\))1 7464 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(2)g(0)28 b(\))f(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)35 b(x)18
+ b(1)g(0)g(0)g(c)g(f)g(f)g(7)g(8)g(0)32 b(\))1 7622 y
+ Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(c)g(0)26
+ b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)35 b(x)18 b(1)g(0)g(0)g(c)g(f)g(f)g(8)g(2)g(0)32
+ b(\))7 7779 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(1)g(0)g
+ (0)24 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)34 b(x)17 b(1)g(0)g(0)g(c)g(f)g(c)g(e)g(6)g
+ (0)30 b(\))1 7937 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(c)g(0)26 b(\))h(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)36 b(x)19
+ b(1)g(0)g(0)g(c)g(f)g(c)g(f)g(0)g(0)30 b(\))1 8095 y
+ Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(4)g(3)g(f)g(2)g(0)28
+ b(\))f(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(f)g(0)g(1)g(d)g(0)27
+ b(\))7 8253 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(1)g(0)g
+ (0)24 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(2)g(7)g
+ (0)25 b(\))7 8410 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(0)g(6)g
+ (0)24 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(3)g(1)g
+ (0)25 b(\))1 8568 y Fi(b)q(e)53 b Fo(\045)19 b(c)f(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)32 b(x)14 b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g
+ (0)27 b(\))g(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)34 b(\()j(l)23
+ b(a)f(b)g(e)g(l)123 b(E)16 b(p)g(i)g(l)g(o)g(g)g(u)g(e)30
+ b(\))-2 8726 y Fi(n)n(o)n(p)0 8883 y(ba)51 b Fo(\045)18
+ b(d)f(i)g(s)g(p)34 b(\()j(l)23 b(a)f(b)g(e)g(l)122 b(K)14
+ b(e)g(r)g(n)g(e)g(l)30 b(\))-2 9041 y Fi(n)n(o)n(p)1064
+ 9533 y Fx(Figure)60 b(4.12:)80 b(Mo)5 b(dulo)59 b(Sc)-5
+ b(heduled)60 b(Lo)5 b(op)60 b(for)g(our)h(Example)e(Lo)5
+ b(op)60 b(\(Prologue\))3809 11136 y(46)p eop end
+ %%Page: 47 54
+ TeXDict begin 47 53 bop 14 210 a Fo(K)14 b(e)g(r)g(n)g(e)g(l)39
+ b(:)7 368 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)36 b(x)19 b(1)g(0)g(0)g(c)g(f)g(f)g(6)g(e)g
+ (0)33 b(\))j(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(0)g(5)g(7)g(5)g
+ (0)22 b(\))1 526 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)35 b(x)18
+ b(1)g(0)g(0)g(c)g(f)g(f)g(7)g(8)g(0)31 b(\))c(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12
+ b(1)g(0)g(0)g(d)g(4)g(4)g(2)g(2)g(0)22 b(\))1 683 y Fi(f)q(m)q(o)q(v)q
+ (s)52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)35 b(x)18 b(1)g(0)g(0)g(c)g(f)g(f)g(8)g(2)g(0)31
+ b(\))c(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(4)g(a)g(c)g(e)g(0)27
+ b(\))7 841 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)34 b(x)17 b(1)g(0)g(0)g(c)g(f)g(c)g(e)g(6)g
+ (0)33 b(\))j(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(0)g(5)g(6)g(b)g
+ (0)24 b(\))14 999 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(h)t(h)t(\()o(\045)16 b(d)h(i)g(s)g(p)34 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17
+ b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(a)g(9)g(0)22 b(\))-1 1156 y Fi(a)o(d)o(d)48 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(0)g(2)g(0)g(0)117 b(i)50 b(.)28
+ b(0)f(.)h(0)f(:)32 b(P)5 b(h)g(i)g(C)g(p)19 b(\))27 b(,)73
+ b(\045)20 b(g)7 b(0)26 b(,)73 b(\045)28 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g
+ (0)122 b(i)48 b(.)25 b(0)f(.)h(0)g(\))14 1314 y Fi(s)14
+ b(e)g(t)g(h)g(i)67 b Fo(\045)5 b(l)t(m)s(\()o(\045)16
+ b(d)h(i)g(s)g(p)34 b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q
+ Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16
+ b(\))30 b(,)79 b(\045)32 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(c)g(7)g(0)29
+ b(\))14 1472 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(l)t(m)14 b(\()20 b Fg(\000)10 b Fo(1)g(\))20 b(,)65
+ b(\045)26 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g(0)23 b(\))7
+ 1630 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(a)g(9)g(0)20
+ b(\))27 b(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g(0)25 b(\))7 1787 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(b)g(2)g(0)21
+ b(\))27 b(,)74 b(\045)32 b(l)20 b(o)30 b(\()20 b Fg(\000)10
+ b Fo(1)g(\))20 b(,)65 b(\045)26 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g(0)30
+ b(\))20 1945 y Fi(s)20 b(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(3)g
+ (0)28 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(3)g
+ (1)g(b)g(d)g(0)27 b(\))15 2103 y(f)15 b(m)g(u)g(l)g(s)65
+ b(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)13 b(1)g(0)g(0)g(d)g(4)g(a)g(c)g(e)g(0)26 b(\))h(,)74
+ b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(2)g(2)g(0)21 b(\))26
+ b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)28 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g(0)94
+ b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))-1 2261 y Fi(a)o(d)o(d)48
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)31
+ b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122 b(i)43
+ b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(e)g(a)g(8)g
+ (0)28 b(\))e(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))7 2418 y Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(c)g(7)g(0)28 b(\))f(,)74
+ b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)27
+ b(x)10 b(1)g(0)g(0)g(d)g(3)g(1)g(b)g(d)g(0)26 b(\))g(,)74
+ b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)27
+ b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g(0)25 b(\))19
+ 2576 y Fi(s)19 b(r)g(l)71 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(0)g(e)g(9)g(e)g
+ (0)104 b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35
+ b(,)83 b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)95
+ b(t)q(m)q(p)23 b(.)g(8)f(\))7 2734 y Fi(o)7 b(r)58 b
+ Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(d)g(1)g(0)23 b(\))k(,)74
+ b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34 b(\()24
+ b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g(0)30 b(\))25 2892 y
+ Fi(s)25 b(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g(9)g(a)g(5)g(0)95
+ b(t)q(m)q(p)20 b(.)g(8)g(\))38 b(,)87 b(2)39 b(,)87 b(\045)36
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12
+ b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(5)g(0)22 b(\))-1 3049 y
+ Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(f)g(0)32
+ b(\))j(,)83 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)27 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g
+ (0)108 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)20 b(A)n(2)12 b(\))11 3207 y Fi(l)f(d)63 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(7)g(3)g(a)g(0)108 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)
+ g(l)g(o)g(b)g(a)g(l)38 b(:)21 b(A)n(2)10 b(\))27 b(,)73
+ b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)12 b(1)g(0)g(0)g(d)g(3)g(1)g(9)g(5)g(0)21 b(\))26
+ b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)29 b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)97
+ b(t)q(m)q(p)21 b(.)g(1)g(1)g(\))1 3365 y Fi(f)q(m)q(o)q(v)q(s)52
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)13 b(1)g(0)g(0)g(b)g(b)g(9)g(b)g(f)g(0)96 b(t)q(m)q(p)18
+ b(.)f(1)g(1)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(0)g(5)g(6)g(1)g
+ (0)22 b(\))14 3523 y Fi(s)14 b(t)65 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g
+ (0)93 b(t)q(m)q(p)18 b(.)f(1)g(2)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)27 b(x)11
+ b(1)g(0)g(0)g(d)g(0)g(5)g(6)g(b)g(0)24 b(\))i(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(0)g(5)g(7)g(5)g(0)22 b(\))25 3680 y
+ Fi(s)j(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122
+ b(i)44 b(.)21 b(0)g(.)g(0)g(\))42 b(,)90 b(2)42 b(,)90
+ b(\045)37 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g(0)24 b(\))7
+ 3838 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(3)g(1)g(8)g(b)g(0)27
+ b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(2)g
+ (0)29 b(\))14 3996 y Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5
+ b(h)t(h)t(\()o(\045)16 b(d)h(i)g(s)g(p)34 b(\()24 b(a)9
+ b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5 b Fo(v)17
+ b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g
+ (2)g(f)g(6)g(0)29 b(\))14 4154 y Fi(s)14 b(e)g(t)g(h)g(i)67
+ b Fo(\045)5 b(l)t(m)s(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)93 b(A)5 b(\))16 b(\))30 b(,)79 b(\045)32
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g(0)29 b(\))14 4311 y
+ Fi(s)14 b(e)g(t)g(h)g(i)67 b Fo(\045)5 b(h)t(h)h(\()r
+ Fh(<)11 b Fo(c)e(p)14 b(#)t(1)7 b Fh(>)t Fo(\))g(,)52
+ b(\045)20 b(r)c(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)22 b(\))7
+ 4469 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(1)g(2)g(f)g(6)g(0)28
+ b(\))f(,)74 b(\045)t(h)-9 b(m)f(\()o(\045)16 b(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g(0)22 b(\))7 4627 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(0)g(6)g(0)20
+ b(\))27 b(,)74 b(\045)t(h)-9 b(m)h(\()r Fh(<)11 b Fo(c)e(p)k(#)t(1)7
+ b Fh(>)t Fo(\))g(,)53 b(\045)20 b(r)c(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g(0)22
+ b(\))20 4785 y Fi(s)e(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(3)g(0)g(0)g
+ (0)25 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g
+ (0)g(6)g(4)g(0)21 b(\))14 4942 y Fi(s)14 b(e)g(t)g(h)g(i)67
+ b Fo(\045)5 b(l)t(m)g(\()r Fh(<)11 b Fo(c)e(p)14 b(#)t(1)7
+ b Fh(>)t Fo(\))g(,)52 b(\045)20 b(r)c(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g(0)22
+ b(\))20 5100 y Fi(s)e(l)g(l)g(x)69 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(4)g
+ (0)25 b(\))34 b(,)82 b(3)17 b(2)35 b(,)82 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g
+ (5)g(7)g(e)g(0)29 b(\))7 5258 y Fi(o)7 b(r)58 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(1)g(8)g(1)g(0)g(0)20 b(\))27 b(,)74
+ b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(7)g(e)g(0)28 b(\))e(,)74
+ b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)28
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g(0)22 b(\))7
+ 5416 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(e)g(0)28
+ b(\))f(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(6)g(4)g(0)21
+ b(\))26 b(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)22
+ b(\))7 5573 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(1)g(5)g(8)g(8)g
+ (0)20 b(\))27 b(,)74 b(\045)32 b(l)20 b(o)h(\()r Fh(<)11
+ b Fo(c)e(p)k(#)t(1)7 b Fh(>)t Fo(\))g(,)53 b(\045)20
+ b(r)c(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g(0)27 b(\))-1 5731 y
+ Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(b)g(a)g(f)g(6)g(a)g(0)122
+ b(i)44 b(.)21 b(0)g(.)g(0)g(\))42 b(,)90 b(1)42 b(,)90
+ b(\045)37 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)31
+ b(x)15 b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104 b(m)6
+ b(a)g(s)g(k)g(H)g(i)23 b(\))7 5889 y Fi(o)7 b(r)58 b
+ Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(1)g(0)g(7)g(8)g(0)20 b(\))27
+ b(,)74 b(\045)32 b(l)20 b(o)f(\()o(\045)d(d)h(i)g(s)g(p)34
+ b(\()24 b(a)9 b(d)g(d)g(r)f Fg(\000)q Fo(o)14 b(f)h Fg(\000)5
+ b Fo(v)17 b(a)g(l)92 b(A)5 b(\))16 b(\))31 b(,)79 b(\045)31
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)25 b(\))11 6046 y
+ Fi(l)11 b(d)63 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(1)g(2)g(e)g(c)g(0)30
+ b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(1)g(7)g(f)g(c)g
+ (0)27 b(\))1 6204 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(d)g(1)g(7)g(f)g(c)g(0)26 b(\))h(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(c)g(0)27 b(\))19 6362 y
+ Fi(s)19 b(r)g(l)71 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(f)g(b)g(2)g(0)g(0)104
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83
+ b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)109 b(i)16
+ b(n)g(d)g(v)g(a)g(r)40 b(.)c(n)14 b(e)g(x)g(t)28 b(\))-1
+ 6520 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)109
+ b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(.)d(n)14 b(e)g(x)g(t)26
+ b(\))h(,)73 b(\045)20 b(g)7 b(0)26 b(,)73 b(\045)28 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(b)g(b)g
+ (0)g(2)g(0)g(0)117 b(i)51 b(.)27 b(0)g(.)h(0)f(:)32 b(P)5
+ b(h)g(i)g(C)g(p)21 b(\))-1 6677 y Fi(a)o(d)o(d)48 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(3)g(3)g(d)g(3)g(0)27 b(\))35 b(,)83
+ b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)27 b(x)11 b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)108
+ b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)g(l)g(o)g(b)g(a)g(l)39
+ b(:)20 b(A)n(1)12 b(\))7 6835 y Fi(o)7 b(r)58 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(b)g(b)g(7)g(4)g(6)g(0)108 b(a)13 b(d)g(d)g(r)g(O)g(f)g(G)
+ g(l)g(o)g(b)g(a)g(l)38 b(:)21 b(A)n(1)14 b(\))36 b(,)82
+ b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(1)g(6)g(0)29
+ b(\))6 6993 y Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(b)g(b)g(9)g(e)g(4)g(0)108 b(i)16 b(n)g(d)g(v)g(a)g(r)40
+ b(.)d(n)14 b(e)g(x)g(t)30 b(\))k(,)82 b(5)17 b(0)g(0)33
+ b(,)81 b(\045)24 b(g)7 b(0)26 b(,)72 b(\045)31 b(c)18
+ b(c)g(r)g(e)g(g)33 b(\()f(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g(0)30 b(\))7 7151 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(2)g(0)32
+ b(\))k(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)36 b(x)19 b(1)g(0)g(0)g(c)g(f)g(f)g(6)g(e)g
+ (0)30 b(\))1 7308 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(c)g(0)26 b(\))h(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)35 b(x)18
+ b(1)g(0)g(0)g(c)g(f)g(f)g(7)g(8)g(0)32 b(\))1 7466 y
+ Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(0)g(5)g(6)g(1)g(0)20
+ b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)35 b(x)18 b(1)g(0)g(0)g(c)g(f)g(f)g(8)g(2)g(0)32
+ b(\))7 7624 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(1)g(6)g
+ (0)32 b(\))k(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)34 b(x)17 b(1)g(0)g(0)g(c)g(f)g(c)g(e)g(6)g
+ (0)30 b(\))1 7782 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(0)g(5)g(6)g(1)g(0)20 b(\))27 b(,)74
+ b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)36
+ b(x)19 b(1)g(0)g(0)g(c)g(f)g(c)g(f)g(0)g(0)30 b(\))1
+ 7939 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(c)g
+ (0)26 b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(f)g(0)g(1)g(d)g(0)27
+ b(\))7 8097 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(1)g(6)g
+ (0)32 b(\))k(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(2)g(7)g
+ (0)25 b(\))7 8255 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(0)g(2)g
+ (0)32 b(\))k(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(3)g(1)g
+ (0)25 b(\))1 8413 y Fi(b)q(e)53 b Fo(\045)19 b(c)f(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)32 b(x)14 b(1)g(0)g(0)g(d)g(3)g(4)g(3)g(f)g
+ (0)27 b(\))g(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)34 b(\()j(l)23
+ b(a)f(b)g(e)g(l)123 b(E)16 b(p)g(i)g(l)g(o)g(g)g(u)g(e)30
+ b(\))-2 8570 y Fi(n)n(o)n(p)0 8728 y(ba)51 b Fo(\045)18
+ b(d)f(i)g(s)g(p)34 b(\()j(l)23 b(a)f(b)g(e)g(l)122 b(K)14
+ b(e)g(r)g(n)g(e)g(l)30 b(\))-2 8886 y Fi(n)n(o)n(p)16
+ 9201 y Fo(E)16 b(p)g(i)g(l)g(o)g(g)g(u)g(e)37 b(:)1 9359
+ y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)36 b(x)19 b(1)g(0)g(0)g(c)g(f)g(c)g(f)g(0)g
+ (0)29 b(\))e(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(2)g(8)g(0)29
+ b(\))1 9517 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(f)g(0)g(1)g(d)g
+ (0)26 b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(3)g(2)g(0)29
+ b(\))15 9675 y(f)15 b(m)g(u)g(l)g(s)65 b(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(2)g(8)g
+ (0)28 b(\))f(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(3)g(2)g(0)28
+ b(\))e(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)28 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g(0)94
+ b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))7 9832 y Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)33
+ b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(2)g(7)g(0)27 b(\))36
+ b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(4)g(4)g(2)g(c)g(0)29
+ b(\))7 9990 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)33 b(x)16 b(1)g(0)g(0)g(c)g(f)g(0)g(3)g(1)g
+ (0)27 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(2)g(c)g(4)g(d)g
+ (0)23 b(\))14 10148 y Fi(s)14 b(t)65 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(b)g(b)g(9)g(c)g(7)g
+ (0)93 b(t)q(m)q(p)18 b(.)f(1)g(2)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(4)g(4)g(2)g(c)g(0)28 b(\))e(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(2)g(c)g(4)g(d)g(0)23 b(\))0 10306 y
+ Fi(ba)51 b Fo(\045)18 b(d)f(i)g(s)g(p)34 b(\()j(l)23
+ b(a)f(b)g(e)g(l)128 b(l)21 b(o)g(o)g(p)g(e)g(x)g(i)g(t)35
+ b(\))-2 10463 y Fi(n)n(o)n(p)600 10955 y Fx(Figure)59
+ b(4.13:)80 b(Mo)5 b(dulo)60 b(Sc)-5 b(heduled)59 b(Lo)5
+ b(op)60 b(for)h(our)f(Example)f(Lo)5 b(op)61 b(\(Kernel)f(and)g
+ (Epilogue\))3809 11136 y(47)p eop end
+ %%Page: 48 55
+ TeXDict begin 48 54 bop 0 1428 a Fv(Chapter)129 b(5)0
+ 2258 y Fw(Extending)156 b(Swing)g(Mo)13 b(dulo)156 b(Sc)-13
+ b(heduling)0 2756 y(for)155 b(Sup)13 b(erblo)g(c)-13
+ b(ks)0 3786 y Fx(On)56 b(man)-5 b(y)56 b(programs,)f(Swing)h(Mo)5
+ b(dulo)55 b(Sc)-5 b(heduling)54 b(is)i(limited)d(b)-5
+ b(y)56 b(only)f(handling)g(single)f(basic)h(blo)5 b(c)-5
+ b(k)55 b(lo)5 b(ops.)0 4151 y(The)46 b(p)5 b(oten)-5
+ b(tial)43 b(for)i(parallelism)e(is)h(increased)h(if)f(instructions)g
+ (can)h(b)5 b(e)45 b(mo)-5 b(v)g(ed)45 b(across)f(basic)h(blo)5
+ b(c)-5 b(k)44 b(b)5 b(oundaries,)0 4517 y(whic)-5 b(h)41
+ b(means)g(that)g(instructions)f(are)h(mo)-5 b(v)g(ed)41
+ b(across)g(conditional)f(branc)-5 b(hes.)73 b(Ho)-5 b(w)g(ev)g(er,)46
+ b(mo)-5 b(ving)40 b(instructions)0 4882 y(ab)5 b(o)-5
+ b(v)g(e)60 b(or)h(b)5 b(elo)-5 b(w)60 b(a)h(conditional)d(branc)-5
+ b(h)60 b(can)h(alter)f(the)g(programs)g(b)5 b(eha)-5
+ b(vior)60 b(if)f(not)i(done)f(safely)-15 b(.)282 5247
+ y(T)g(raditional)54 b(Mo)5 b(dulo)55 b(Sc)-5 b(heduling)54
+ b(tec)-5 b(hniques)54 b(only)h(transform)g(single)f(basic)g(blo)5
+ b(c)-5 b(k)55 b(lo)5 b(ops)55 b(without)g(con-)0 5613
+ y(trol)93 b(\015o)-5 b(w,)101 b(resulting)92 b(in)i(man)-5
+ b(y)92 b(missed)g(opp)5 b(ortunities)92 b(for)h(parallelism.)177
+ b(Ho)-5 b(w)g(ev)g(er,)101 b(v)-5 b(ery)94 b(few)f(Mo)5
+ b(dulo)0 5978 y(Sc)-5 b(heduling)50 b(tec)-5 b(hniques)49
+ b(can)i(handle)f(m)-5 b(ultiple)49 b(basic)h(blo)5 b(c)-5
+ b(k)50 b(lo)5 b(ops.)77 b(These)51 b(tec)-5 b(hniques,)50
+ b(called)g(Global)g(Mo)5 b(d-)0 6344 y(ulo)71 b(Sc)-5
+ b(heduling,)72 b(w)-5 b(ere)72 b(discussed)e(in)h(Section)f(3.2.)113
+ b(All)71 b(Global)f(Mo)5 b(dulo)71 b(Sc)-5 b(heduling)70
+ b(algorithms)f([25,)i(41)o(])0 6709 y(sc)-5 b(hedule)48
+ b Fb(al)9 b(l)56 b(p)-9 b(aths)50 b Fx(within)f(the)g(lo)5
+ b(op,)51 b(whic)-5 b(h)49 b(in)-5 b(v)g(olv)g(es)48 b(taking)g
+ (resource)i(usage)f(and)g(dep)5 b(endence)49 b(constrain)-5
+ b(ts)0 7074 y(for)64 b(eac)-5 b(h)64 b(execution)f(path.)90
+ b(Ho)-5 b(w)g(ev)g(er,)65 b(one)f(execution)f(path)h(ma)-5
+ b(y)64 b(b)5 b(e)64 b(tak)-5 b(en)64 b(more)f(often)h(than)f(another.)
+ 91 b(In)0 7440 y(these)71 b(situations,)g(Mo)5 b(dulo)71
+ b(Sc)-5 b(heduling)70 b(should)h(aim)f(to)h(decrease)g(the)g(execution)
+ f(time)g(for)h(the)g(most)g(fre-)0 7805 y(quen)-5 b(tly)52
+ b(executed)g(path)h(ev)-5 b(en)53 b(though)g(this)f(could)h(increase)f
+ (the)h(execution)f(time)g(of)h(the)f(less)h(frequen)-5
+ b(t)52 b(path.)0 8170 y(Ov)-5 b(erall,)59 b(the)i(p)5
+ b(erformance)59 b(of)h(the)g(program)g(will)g(b)5 b(e)60
+ b(increased.)282 8536 y(T)-15 b(race)47 b(Sc)-5 b(heduling)45
+ b(is)h(a)h(tec)-5 b(hnique)45 b(for)h(general)g(instruction)f(sc)-5
+ b(heduling)45 b(\(not)h(Soft)-5 b(w)g(are)46 b(Pip)5
+ b(elining\))44 b(that)0 8901 y(sc)-5 b(hedules)60 b(frequen)-5
+ b(tly)60 b(executed)g(paths,)g(called)g(traces.)82 b(T)-15
+ b(races)61 b(are)g(a)g(sequence)g(of)f(basic)h(blo)5
+ b(c)-5 b(ks)60 b(that)h(ma)-5 b(y)0 9267 y(ha)g(v)g(e)67
+ b(exits)e(out)i(of)g(the)f(middle)g(\(called)f(side)h(exits\),)h(and)g
+ (transitions)e(from)h(other)h(traces)f(in)-5 b(to)66
+ b(the)h(middle)0 9632 y(\(called)78 b(side)h(en)-5 b(trances\).)137
+ b(These)79 b(m)-5 b(ultiple-en)g(try)77 b(m)-5 b(ultiple-exit)76
+ b(groups)k(of)f(basic)g(blo)5 b(c)-5 b(ks)79 b(are)g(sc)-5
+ b(heduled)0 9997 y(ignoring)83 b(the)g(side)g(exits)g(and)h(en)-5
+ b(trances,)88 b(but)c(extra)g(b)5 b(o)g(okk)-5 b(eeping)83
+ b(is)g(done)g(to)h(ensure)g(the)f(program)h(is)0 10363
+ y(correct)53 b(regardless)f(of)h(whic)-5 b(h)53 b(path)g(is)g(tak)-5
+ b(en.)77 b(This)53 b(b)5 b(o)g(okk)-5 b(eeping)52 b(increases)g(the)h
+ (complexit)-5 b(y)51 b(of)i(sc)-5 b(heduling.)3809 11136
+ y(48)p eop end
+ %%Page: 49 56
+ TeXDict begin 49 55 bop 0 183 a Fx(Remo)-5 b(ving)59
+ b(the)h(side)g(en)-5 b(trances)59 b(forms)h(a)g(sup)5
+ b(erblo)g(c)-5 b(k,)59 b(whic)-5 b(h)61 b(decreases)e(the)h(sc)-5
+ b(heduling)59 b(complexit)-5 b(y)-15 b(.)282 548 y(W)g(e)56
+ b(extended)e(Swing)i(Mo)5 b(dulo)55 b(Sc)-5 b(heduling)54
+ b(to)h(supp)5 b(ort)56 b(sup)5 b(erblo)g(c)-5 b(k)55
+ b(lo)5 b(ops)54 b(in)i(order)g(to)f(tak)-5 b(e)55 b(adv)-10
+ b(an)-5 b(tage)0 913 y(of)46 b(the)f(parallelism)f(of)i(m)-5
+ b(ultiple)43 b(basic)i(blo)5 b(c)-5 b(k)46 b(lo)5 b(ops.)75
+ b(This)45 b(c)-5 b(hapter)46 b(will)f(discuss)g(the)h(details)e(of)i
+ (what)g(c)-5 b(hanges)0 1279 y(w)g(ere)61 b(made)f(to)g(the)g
+ (algorithm)f(describ)5 b(ed)59 b(in)h(Chapter)h(4.)282
+ 1644 y(While)67 b(these)g(extensions)g(w)-5 b(ere)68
+ b(implemen)-5 b(ted)65 b(as)j(a)g(static)e(optimization)g(in)h(the)h
+ (SP)-15 b(AR)-5 b(C)68 b(V9)h(bac)-5 b(k)g(end)0 2010
+ y(of)71 b(the)g(LL)-20 b(VM)71 b(Compiler)f(Infrastructure,)i(it)f(can)
+ g(seamlessly)e(b)5 b(e)71 b(applied)f(to)h(sup)5 b(erblo)g(c)-5
+ b(k)71 b(lo)5 b(ops)70 b(found)h(at)0 2375 y(run)-5 b(time)59
+ b(or)i(o\017ine)e(using)h(pro\014le)g(information.)0
+ 3125 y Ft(5.1)270 b(Ov)-7 b(erview)0 3670 y Fx(W)-15
+ b(e)43 b(extended)g(Swing)h(Mo)5 b(dulo)43 b(Sc)-5 b(heduling)42
+ b(to)i(handle)f(sup)5 b(erblo)g(c)-5 b(k)43 b(lo)5 b(ops,)45
+ b(whic)-5 b(h)44 b(are)g(single-en)-5 b(try)-15 b(,)44
+ b(m)-5 b(ultiple-)0 4036 y(exit,)53 b(m)-5 b(ultiple)50
+ b(basic)i(blo)5 b(c)-5 b(k)51 b(lo)5 b(ops.)77 b(These)52
+ b(extensions)f(allo)-5 b(w)52 b(instructions)e(to)j(b)5
+ b(e)52 b(mo)-5 b(v)g(ed)52 b(ab)5 b(o)-5 b(v)g(e)52 b(conditional)0
+ 4401 y(branc)-5 b(hes)60 b(\(up)-5 b(w)g(ard)61 b(co)5
+ b(de)60 b(motion\))f(or)i(b)5 b(elo)-5 b(w)60 b(conditional)e(branc)-5
+ b(hes)60 b(\(do)-5 b(wn)g(w)g(ard)61 b(co)5 b(de)60 b(motion\).)282
+ 4766 y(Do)-5 b(wn)g(w)g(ard)75 b(co)5 b(de)73 b(motion)g(o)5
+ b(ccurs)74 b(when)g(an)g(instruction)e(is)h(mo)-5 b(v)g(ed)74
+ b(b)5 b(elo)-5 b(w)73 b(a)h(conditional)e(branc)-5 b(h.)121
+ b(It)0 5132 y(is)62 b(fairly)g(straigh)-5 b(t)62 b(forw)-5
+ b(ard)63 b(and)g(only)g(requires)f(that)h(the)f(branc)-5
+ b(h)64 b(is)e(not)h(dep)5 b(enden)-5 b(t)62 b(up)5 b(on)63
+ b(the)g(instruction)0 5497 y(that)74 b(is)g(b)5 b(eing)75
+ b(mo)-5 b(v)g(ed.)122 b(A)75 b(cop)-5 b(y)75 b(of)f(that)g(instruction)
+ f(is)i(placed)f(in)g(the)g(side)g(exit)g(in)h(the)f(ev)-5
+ b(en)g(t)74 b(that)g(the)0 5862 y(branc)-5 b(h)61 b(w)-5
+ b(as)60 b(actually)f(tak)-5 b(en,)59 b(ensuring)h(that)g(the)g
+ (programs)g(b)5 b(eha)-5 b(vior)60 b(is)g(unaltered.)282
+ 6228 y(Up)-5 b(w)g(ard)65 b(co)5 b(de)65 b(motion)e(is)g(the)h(pro)5
+ b(cess)64 b(of)g(mo)-5 b(ving)63 b(an)i(instruction)d(ab)5
+ b(o)-5 b(v)g(e)64 b(a)h(conditional)d(branc)-5 b(h.)92
+ b(The)0 6593 y(execution)74 b(of)g(this)g(instruction)g(is)g(termed)g
+ (\\sp)5 b(eculativ)-5 b(e)73 b(execution",)k(b)5 b(ecause)74
+ b(the)h(execution)f(of)g(the)h(in-)0 6959 y(struction)h(o)5
+ b(ccurs)77 b(b)5 b(efore)76 b(it)h(w)-5 b(ould)76 b(ha)-5
+ b(v)g(e)77 b(\(or)g(not)g(ha)-5 b(v)g(e\))77 b(in)f(original)g(program)
+ h(order.)130 b(This)77 b(instruction)0 7324 y(originally)57
+ b(w)-5 b(as)60 b(executed)e(only)h(if)f(the)h(branc)-5
+ b(h)59 b(w)-5 b(as)59 b(not)g(tak)-5 b(en.)80 b(Up)-5
+ b(w)g(ard)60 b(co)5 b(de)59 b(motion)e(is)i(useful)f(for)h(hiding)0
+ 7689 y(the)69 b(latency)f(of)h(load)g(instructions)e(or)i(other)g(high)
+ g(latency)f(instructions.)105 b(In)69 b(order)g(for)h(an)f(instruction)
+ e(to)0 8055 y(b)5 b(e)60 b(a)h(candidate)e(for)i(up)-5
+ b(w)g(ard)61 b(co)5 b(de)60 b(motion,)e(t)-5 b(w)g(o)61
+ b(restrictions)d(m)-5 b(ust)60 b(b)5 b(e)60 b(met)g([8)o(,)g(29]:)222
+ 8570 y(1.)91 b Fj(The)75 b(destination)h(of)f(the)g(instruction)i(m)-6
+ b(ust)76 b(not)f(b)6 b(e)75 b(used)h(b)6 b(efore)74 b(it)i(is)f
+ (rede\014ned)h(when)455 8935 y(the)70 b(branc)-6 b(h)70
+ b(is)g(tak)-6 b(en)70 b(\(exited)h(from)e(sup)6 b(erblo)g(c)-6
+ b(k\).)222 9434 y Fx(2.)91 b Fj(The)69 b(instruction)i(m)-6
+ b(ust)70 b(nev)-6 b(er)70 b(cause)f(an)g(exception)h(that)g(ma)-6
+ b(y)69 b(halt)h(the)f(programs)g(exe-)455 9799 y(cution)g(when)h(the)g
+ (branc)-6 b(h)70 b(is)h(tak)-6 b(en.)282 10315 y Fx(The)54
+ b(\014rst)f(restriction)f(ensures)h(that)g(if)g(an)g(instruction)f(is)h
+ (mo)-5 b(v)g(ed)53 b(ab)5 b(o)-5 b(v)g(e)53 b(a)h(branc)-5
+ b(h)53 b(and)h(that)f(instruction)0 10680 y(de\014nes)g(a)h(v)-10
+ b(alue,)54 b(then)g(if)f(the)g(branc)-5 b(h)54 b(is)f(tak)-5
+ b(en,)55 b(all)e(instructions)e(after)j(the)f(branc)-5
+ b(h)54 b(will)f(not)h(use)f(that)g(v)-10 b(alue.)3809
+ 11136 y(49)p eop end
+ %%Page: 50 57
+ TeXDict begin 50 56 bop 0 183 a Fx(By)59 b(mo)-5 b(ving)58
+ b(the)h(instruction)e(ab)5 b(o)-5 b(v)g(e)59 b(the)g(branc)-5
+ b(h,)59 b(w)-5 b(e)59 b(are)h(p)5 b(erforming)58 b(a)h(computation)e
+ (that)i(ma)-5 b(y)58 b(not)h(ha)-5 b(v)g(e)0 548 y(b)5
+ b(een)74 b(executed)f(in)g(the)h(original)f(program.)120
+ b(Therefore,)77 b(if)c(the)h(branc)-5 b(h)74 b(w)-5 b(as)74
+ b(miss-predicted,)f(w)-5 b(e)75 b(need)e(to)0 913 y(guaran)-5
+ b(tee)58 b(that)g(instructions)e(after)i(the)g(branc)-5
+ b(h)58 b(are)g(using)g(the)g(righ)-5 b(t)58 b(v)-10 b(alue)57
+ b(\(as)h(in)g(the)g(original)f(program\).)282 1279 y(Because)76
+ b(the)h(LL)-20 b(VM)76 b(Compiler)g(Infrastructure)g(In)-5
+ b(termediate)74 b(represen)-5 b(tation)76 b(and)h(the)g(SP)-15
+ b(AR)-5 b(C)77 b(V9)0 1644 y(bac)-5 b(k)g(end)69 b(in)-5
+ b(termediate)66 b(represen)-5 b(tation)68 b(are)h(in)g(SSA)g(form,)i
+ (there)d(is)h(no)g(risk)g(of)f(an)-5 b(y)69 b(v)-10 b(alue)69
+ b(b)5 b(eing)68 b(de\014ned)0 2010 y(t)-5 b(wice.)79
+ b(Ho)-5 b(w)g(ev)g(er,)60 b(b)5 b(ecause)59 b(Swing)h(Mo)5
+ b(dulo)59 b(Sc)-5 b(heduling)58 b(is)i(attempting)d(to)j(o)-5
+ b(v)g(erlap)59 b(iterations)f(of)i(the)f(lo)5 b(op,)0
+ 2375 y(and)53 b(lo)5 b(ops)53 b(can)g(rede\014ne)g(dynamic)f(v)-10
+ b(alues,)53 b(it)g(is)f(imp)5 b(ortan)-5 b(t)52 b(to)h(not)g
+ (rede\014ne)g(the)g(v)-10 b(alue)53 b(b)5 b(efore)52
+ b(the)h(outcome)0 2740 y(of)60 b(the)g(side)g(exit)f(is)h(kno)-5
+ b(wn.)282 3106 y(The)69 b(second)f(restriction)f(guards)h(against)g
+ (exceptions)f(from)h(halting)f(the)h(program)h(due)f(to)h(mo)-5
+ b(ving)67 b(an)0 3471 y(instruction)75 b(ab)5 b(o)-5
+ b(v)g(e)77 b(a)g(branc)-5 b(h.)129 b(Because)76 b(the)g(instruction)f
+ (mo)-5 b(v)g(ed)77 b(ab)5 b(o)-5 b(v)g(e)76 b(the)h(branc)-5
+ b(h)77 b(is)f(b)5 b(eing)76 b(executed)0 3836 y(b)5 b(efore)67
+ b(it)g(w)-5 b(ould)68 b(ha)-5 b(v)g(e)67 b(in)g(the)g(original)g
+ (program)g(it)g(ma)-5 b(y)67 b(nev)-5 b(er)68 b(ha)-5
+ b(v)g(e)67 b(b)5 b(een)67 b(executed.)101 b(This)67 b(exception)g(is)0
+ 4202 y(not)60 b(one)h(that)f(w)-5 b(ould)60 b(ha)-5 b(v)g(e)60
+ b(o)5 b(ccurred)60 b(if)g(the)g(instruction)f(had)h(not)h(b)5
+ b(een)60 b(mo)-5 b(v)g(ed.)282 4567 y(The)60 b(second)f(restriction)e
+ (can)j(b)5 b(e)59 b(relaxed)g(dep)5 b(ending)58 b(up)5
+ b(on)60 b(whic)-5 b(h)59 b(arc)-5 b(hitecture)58 b(SMS)h(is)g(implemen)
+ -5 b(ted)0 4933 y(for.)84 b(F)-15 b(or)61 b(some)g(arc)-5
+ b(hitectures,)60 b(suc)-5 b(h)61 b(as)h(the)f(SP)-15
+ b(AR)-5 b(C)62 b(V9,)g(a)g(subset)f(of)g(instructions)f(can)h(p)5
+ b(oten)-5 b(tial)60 b(trap)i(or)0 5298 y(cause)i(exceptions\(suc)-5
+ b(h)62 b(as)i(\015oating)f(p)5 b(oin)-5 b(t)64 b(arithmetic\).)89
+ b(These)64 b(instructions)e(can)j(not)f(b)5 b(e)64 b(mo)-5
+ b(v)g(ed)64 b(up)-5 b(w)g(ard)0 5663 y(b)5 b(ecause)62
+ b(the)h(programs)f(execution)g(b)5 b(eha)-5 b(vior)62
+ b(could)g(b)5 b(e)63 b(altered)f(\(an)h(exception)e(could)i(cause)f
+ (the)g(program)0 6029 y(to)80 b(abnormally)f(halt\).)139
+ b(If)80 b(the)g(arc)-5 b(hitecture)79 b(pro)-5 b(vides)80
+ b(non-trapping)f(v)-5 b(ersions)80 b(of)g(these)f(instructions)g(or)0
+ 6394 y(general)73 b(supp)5 b(ort)73 b(for)g(predication,)i(those)d(can)
+ h(b)5 b(e)74 b(used)f(instead)f(and)h(the)g(non-trapping)g(instruction)
+ e(can)0 6759 y(safely)59 b(b)5 b(e)61 b(mo)-5 b(v)g(ed)59
+ b(ab)5 b(o)-5 b(v)g(e)60 b(the)h(branc)-5 b(h.)80 b(Unfortunately)-15
+ b(,)58 b(this)i(is)g(not)g(an)h(option)e(for)h(the)h(SP)-15
+ b(AR)-5 b(C)60 b(V9.)282 7125 y(The)48 b(b)5 b(est)48
+ b(t)-5 b(yp)5 b(e)47 b(of)g(hardw)-5 b(are)49 b(supp)5
+ b(ort)47 b(is)g(one)h(that)f(pro)-5 b(vides)47 b Fu(Predicated)g
+ (Execution)p Fx(,)h(suc)-5 b(h)47 b(as)h(IA64)g([20)o(].)0
+ 7490 y(Predicated)i(Execution)g(allo)-5 b(ws)50 b(instructions)f(to)i
+ (b)5 b(e)51 b(n)-5 b(ulli\014ed)49 b(during)i(their)g(execution)f(in)h
+ (the)f(pip)5 b(eline.)76 b(So)51 b(if)0 7856 y(an)46
+ b(instruction)e(is)i(sp)5 b(eculativ)-5 b(ely)43 b(mo)-5
+ b(v)g(ed)46 b(ab)5 b(o)-5 b(v)g(e)45 b(a)i(branc)-5 b(h)46
+ b(and)g(the)g(branc)-5 b(h)46 b(is)f(tak)-5 b(en,)48
+ b(ev)-5 b(en)46 b(if)f(the)h(instruction)0 8221 y(is)82
+ b(already)h(in)g(the)g(pro)5 b(cessor's)81 b(pip)5 b(eline,)87
+ b(the)c(instruction)e(can)i(b)5 b(e)83 b(n)-5 b(ulli\014ed.)147
+ b(Therefore)83 b(the)g(programs)0 8586 y(b)5 b(eha)-5
+ b(vior)60 b(is)g(not)g(altered)g(and)g(v)-10 b(alues)60
+ b(are)g(not)g(incorrectly)f(rede\014ned.)0 9344 y Ft(5.2)270
+ b(Changes)91 b(to)e(Dep)7 b(endence)91 b(Graph)0 9889
+ y Fx(In)62 b(order)h(to)f(successfully)d(Mo)5 b(dulo)62
+ b(Sc)-5 b(hedule)61 b(a)i(sup)5 b(erblo)g(c)-5 b(k)61
+ b(lo)5 b(op)62 b(and)g(main)-5 b(tain)61 b(correct)h(execution)f(of)g
+ (the)0 10255 y(program,)73 b(some)d(c)-5 b(hanges)70
+ b(need)h(to)g(b)5 b(e)71 b(made)f(to)h(the)f(Data)h(Dep)5
+ b(endence)70 b(Graph.)111 b(These)71 b(c)-5 b(hanges)70
+ b(ensure)0 10620 y(that)60 b(the)g(restrictions)e(men)-5
+ b(tion)60 b(in)g(Section)f(5.1)h(for)g(co)5 b(de)60 b(motion)g(are)g
+ (met.)3809 11136 y(50)p eop end
+ %%Page: 51 58
+ TeXDict begin 51 57 bop 282 183 a Fx(Recall)63 b(from)g(Section)g(4.2)g
+ (that)g(a)h(Data)f(Dep)5 b(endence)63 b(Graph)h(consists)e(of)i(no)5
+ b(des)63 b(for)h(eac)-5 b(h)63 b(instruction,)0 548 y(and)h(edges)g
+ (represen)-5 b(t)63 b(the)h(dep)5 b(endence)63 b(b)5
+ b(et)-5 b(w)g(een)64 b(instructions.)89 b(There)64 b(are)h(three)e
+ (main)h(c)-5 b(hanges)63 b(made)g(to)0 913 y(the)d(Data)g(Dep)5
+ b(endence)60 b(Graph:)273 1478 y Fr(\017)91 b Fx(A)61
+ b(predicate)f(no)5 b(de)61 b(is)f(in)-5 b(tro)5 b(duced)61
+ b(to)f(represen)-5 b(t)61 b(the)g(instructions)e(related)h(to)g(the)h
+ (inner)g(branc)-5 b(hes)61 b(of)455 1843 y(the)f(sup)5
+ b(erblo)g(c)-5 b(k.)273 2358 y Fr(\017)91 b Fx(Edges)59
+ b(are)i(created)f(b)5 b(et)-5 b(w)g(een)60 b(the)g(predicate)f(no)5
+ b(de)61 b(and)f(all)g(trapping)g(instructions.)273 2873
+ y Fr(\017)91 b Fx(Edges)55 b(are)h(created)f(b)5 b(et)-5
+ b(w)g(een)56 b(the)g(predicate)e(no)5 b(de)56 b(and)g(all)f
+ (instructions)f(that)i(de\014ne)g(v)-10 b(alues)55 b(that)g(are)455
+ 3238 y(liv)-5 b(e)59 b(if)h(a)g(side)g(exit)f(branc)-5
+ b(h)61 b(is)f(tak)-5 b(en.)282 3803 y(The)76 b(\014rst)e(c)-5
+ b(hange)75 b(in)-5 b(tro)5 b(duces)74 b(a)h(new)g(no)5
+ b(de)75 b(called)f(the)g Fu(predicate)g(no)5 b(de)p Fx(.)124
+ b(This)74 b(no)5 b(de)75 b(represen)-5 b(ts)74 b(the)0
+ 4168 y(instruction)50 b(that)h(computes)f(the)h(condition)f(\(for)h(a)g
+ (conditional)f(branc)-5 b(h\))51 b(and)g(the)g(branc)-5
+ b(h)52 b(itself.)75 b(This)51 b(no)5 b(de)0 4534 y(allo)-5
+ b(ws)56 b(those)g(instructions)f(to)i(b)5 b(e)57 b(treated)g(as)f(one)h
+ (instruction)f(and)h(will)f(b)5 b(e)57 b(sc)-5 b(heduled)56
+ b(for)h(the)f(same)g(stage.)0 4899 y(Ha)-5 b(ving)66
+ b(the)g(condition)e(and)i(branc)-5 b(h)67 b(instructions)d(in)i(the)f
+ (same)h(stage)f(is)g(crucial)g(for)h(prop)5 b(er)67 b(execution)e(of)0
+ 5265 y(the)60 b(sup)5 b(erblo)g(c)-5 b(k)60 b(lo)5 b(op.)282
+ 5630 y(Data)64 b(dep)5 b(endences)64 b(b)5 b(et)-5 b(w)g(een)64
+ b(the)g(predicate)f(no)5 b(de)64 b(and)h(other)f(instructions)f(are)h
+ (created)g(as)g(describ)5 b(ed)0 5995 y(in)54 b(Section)f(4.2,)h(kno)-5
+ b(wing)54 b(whic)-5 b(h)54 b(v)-10 b(alues)53 b(the)h(instructions)e
+ (\(that)h(the)h(predicate)f(no)5 b(de)54 b(represen)-5
+ b(ts\))53 b(uses)g(and)0 6361 y(de\014nes.)96 b(Additionally)-15
+ b(,)65 b(dep)5 b(endences)65 b(are)h(created)f(b)5 b(et)-5
+ b(w)g(een)66 b(a)g(predicate)f(no)5 b(de)66 b(and)g(an)-5
+ b(y)65 b(other)h(predicate)0 6726 y(no)5 b(des)60 b(after)g(it.)79
+ b(This)61 b(is)e(to)i(ensure)f(that)g(the)g(side)g(exits)f(of)h(the)g
+ (sup)5 b(erblo)g(c)-5 b(k)60 b(are)g(preserv)-5 b(ed)60
+ b(in)g(order.)282 7091 y(The)82 b(second)f(c)-5 b(hange)82
+ b(upholds)f(the)g(second)g(co)5 b(de)82 b(motion)e(restriction.)143
+ b(On)82 b(the)f(SP)-15 b(AR)-5 b(C)82 b(V9,)87 b(loads,)0
+ 7457 y(stores,)68 b(in)-5 b(teger)66 b(divide,)i(and)g(all)e
+ (\015oating)h(p)5 b(oin)-5 b(t)66 b(arithmetic)g(p)5
+ b(oten)-5 b(tially)65 b(trap.)101 b(Therefore,)68 b(a)g(dep)5
+ b(endence)0 7822 y(is)71 b(created)g(b)5 b(et)-5 b(w)g(een)71
+ b(those)g(instructions)e(and)j(the)f(predicate)g(no)5
+ b(de)71 b(for)h(the)f(branc)-5 b(h)72 b(that)f(the)g(instruction)0
+ 8188 y(w)-5 b(ould)78 b(b)5 b(e)79 b(mo)-5 b(v)g(ed)78
+ b(ab)5 b(o)-5 b(v)g(e)78 b(\(if)f(allo)-5 b(w)g(ed\).)133
+ b(Because)78 b(of)g(the)g(dep)5 b(endences)77 b(b)5 b(et)-5
+ b(w)g(een)78 b(predicate)g(no)5 b(des,)82 b(it)c(is)0
+ 8553 y(not)c(necessary)f(to)h(add)g(edges)f(b)5 b(et)-5
+ b(w)g(een)74 b(all)f(trapping)g(instructions)f(and)i(all)f(predicate)g
+ (no)5 b(des.)121 b(It)73 b(is)h(only)0 8918 y(necessary)52
+ b(to)g(add)h(them)f(b)5 b(et)-5 b(w)g(een)53 b(the)f(trapping)g
+ (instruction)f(and)i(the)g(predicate)e(no)5 b(de)53 b(for)g(the)f
+ (predecessor)0 9284 y(basic)60 b(blo)5 b(c)-5 b(k.)282
+ 9649 y(Dep)5 b(endences)68 b(b)5 b(et)-5 b(w)g(een)68
+ b(the)g(predicate)f(no)5 b(de)69 b(and)f(load)g(instructions)f(can)h(b)
+ 5 b(e)68 b(eliminated)e(if)i(it)g(can)g(b)5 b(e)0 10014
+ y(pro)-5 b(v)g(en)46 b(that)g(accessing)f(the)h(memory)f(is)h(safe.)74
+ b(This)46 b(o)5 b(ccurs)46 b(when)h(the)f(load)g(is)f(from)h(global)f
+ (or)i(stac)-5 b(k)45 b(memory)0 10380 y(and)61 b(the)f(index)g(is)f
+ (within)h(the)g(legal)f(b)5 b(ounds)61 b(of)f(the)g(memory)f(allo)5
+ b(cated.)3809 11136 y(51)p eop end
+ %%Page: 52 59
+ TeXDict begin 52 58 bop 282 183 a Fx(The)60 b(last)e(c)-5
+ b(hange)59 b(is)f(to)h(prev)-5 b(en)g(t)59 b(a)g(v)-10
+ b(alue)59 b(from)f(b)5 b(eing)59 b(rede\014ned)g(b)5
+ b(efore)59 b(it)f(is)h(used.)79 b(This)59 b(situation)e(can)0
+ 548 y(o)5 b(ccur)67 b(if)g(the)g(predicate)g(no)5 b(de)67
+ b(is)g(sc)-5 b(heduled)66 b(in)h(the)g(k)-5 b(ernel)67
+ b(from)g(a)h(previous)e(iteration)g(\(stage)h Fq(>)h
+ Fx(0\).)101 b(It)67 b(is)0 913 y(p)5 b(ossible)64 b(that)g
+ (instructions)g(that)h(are)g(b)5 b(efore)65 b(the)g(branc)-5
+ b(h)65 b(in)g(the)g(original)f(program,)i(are)f(executed)g(b)5
+ b(efore)0 1279 y(the)68 b(branc)-5 b(h)69 b(is)e(determined)g(to)i(b)5
+ b(e)68 b(tak)-5 b(en)68 b(or)h(not.)103 b(F)-15 b(or)69
+ b(v)-10 b(alues)67 b(that)h(are)g(liv)-5 b(e)68 b(if)f(the)h(branc)-5
+ b(h)69 b(is)f(tak)-5 b(en,)69 b(this)0 1644 y(will)54
+ b(pro)5 b(duce)55 b(incorrect)f(results.)77 b(Therefore)55
+ b(lo)5 b(op-carried)54 b(dep)5 b(endences)54 b(b)5 b(et)-5
+ b(w)g(een)54 b(the)h(predicate)f(no)5 b(de)55 b(and)0
+ 2010 y(all)k(instructions)g(that)g(de\014ne)h(v)-10 b(alues)60
+ b(that)g(are)g(liv)-5 b(e)59 b(outside)g(the)h(trace)g(m)-5
+ b(ust)59 b(b)5 b(e)61 b(created.)79 b(This)60 b(will)f(ensure)0
+ 2375 y(that)72 b(all)g(the)g(instructions)f(that)h(are)h(liv)-5
+ b(e)71 b(if)h(the)g(side)g(exit)g(is)g(tak)-5 b(en)72
+ b(are)h(from)f(the)g(same)g(iteration)f(in)h(the)0 2740
+ y(k)-5 b(ernel.)2396 3159 y Fs(1)196 b Fm(Liv)5 b(eO)t(utside)42
+ b Fs(=)52 b(Empt)l(y)e(list)g(of)h(instructions)2396
+ 3341 y(2)196 b Fn(8)p Fm(n)51 b Fs(instructions)f Fn(2)i
+ Fs(sup)t(erblo)t(c)l(k)2396 3524 y(3)358 b Fn(8)p Fm(u)52
+ b Fn(2)g Fm(uses)p Fs(\()p Fm(n)p Fs(\))2396 3707 y(4)358
+ b(if)51 b(\(!inSup)t(erBlo)t(c)l(k\()p Fm(u)p Fs(\)\))2396
+ 3889 y(5)520 b Fm(Liv)5 b(eO)t(utside:add)p Fs(\()p Fm(n)p
+ Fs(\))1016 4409 y Fx(Figure)60 b(5.1:)80 b(Pseudo)59
+ b(Co)5 b(de)61 b(for)f(Determining)f(V)-15 b(alues)60
+ b(Liv)-5 b(e)59 b(Outside)h(the)g(T)-15 b(race)282 4896
+ y(T)g(o)66 b(determine)e(whic)-5 b(h)65 b(v)-10 b(alues)64
+ b(are)i(liv)-5 b(e)64 b(outside)g(the)h(trace,)h(a)f(simple)f(v)-5
+ b(ersion)64 b(of)h(liv)-5 b(e)65 b(v)-10 b(ariable)64
+ b(analysis)0 5262 y(is)58 b(p)5 b(erformed.)79 b(Figure)118
+ b(5.1)58 b(illustrates)e(the)j(simple)e(approac)-5 b(h)59
+ b(used)g(b)-5 b(y)59 b(our)g(implemen)-5 b(tation.)76
+ b(The)59 b(uses)g(of)0 5627 y(eac)-5 b(h)70 b(instruction)e(are)i
+ (examined.)107 b(Eac)-5 b(h)69 b(using)h(instruction)e(b)5
+ b(elongs)69 b(to)g(a)h(basic)f(blo)5 b(c)-5 b(k)70 b(\(its)e(paren)-5
+ b(t\).)108 b(F)-15 b(or)0 5992 y(eac)-5 b(h)65 b(of)h(the)f(uses)g(of)h
+ (the)f(v)-10 b(alue,)66 b(is)f(basic)g(blo)5 b(c)-5 b(k)65
+ b(is)g(tested)f(to)i(see)f(if)g(it)g(b)5 b(elongs)65
+ b(to)g(the)h(set)f(of)g(basic)g(blo)5 b(c)-5 b(ks)0 6358
+ y(that)65 b(mak)-5 b(e)65 b(up)g(the)g(sup)5 b(erblo)g(c)-5
+ b(k.)95 b(If)65 b(a)g(user)g(is)g(not)g(in)h(the)f(sup)5
+ b(erblo)g(c)-5 b(k,)65 b(the)g(v)-10 b(alue)65 b(is)g(determine)f(to)h
+ (b)5 b(e)65 b(liv)-5 b(e)0 6723 y(outside)59 b(the)h(trace.)0
+ 7481 y Ft(5.3)270 b(Changes)91 b(to)e(Lo)7 b(op)92 b(Reconstruction)0
+ 8026 y Fx(Section)73 b(4.7)h(describ)5 b(ed)73 b(the)h(steps)f(tak)-5
+ b(en)74 b(to)g(reconstruct)f(the)h(mo)5 b(dulo)73 b(sc)-5
+ b(heduled)73 b(lo)5 b(op)74 b(in)-5 b(to)73 b(a)h(prologue,)0
+ 8391 y(k)-5 b(ernel,)86 b(and)c(epilogue.)142 b(The)82
+ b(Swing)g(Mo)5 b(dulo)81 b(Sc)-5 b(heduling)80 b(extensions)g(for)h
+ (sup)5 b(erblo)g(c)-5 b(k)81 b(lo)5 b(ops)81 b(m)-5 b(ust)81
+ b(also)0 8757 y(reconstruct)57 b(the)g(lo)5 b(op)57 b(in)-5
+ b(to)57 b(a)h(prologue,)f(k)-5 b(ernel,)57 b(and)g(epilogue.)78
+ b(The)58 b(main)f(di\013erence)g(b)5 b(et)-5 b(w)g(een)57
+ b(the)g(exten-)0 9122 y(sions)52 b(and)h(the)g(standard)f(algorithm)f
+ (is)i(that)f(the)h(prologue,)g(epilogue,)g(and)g(k)-5
+ b(ernel)52 b(are)h(all)f(sup)5 b(erblo)g(c)-5 b(ks,)53
+ b(and)0 9488 y(consist)j(of)i(m)-5 b(ultiple)55 b(basic)i(blo)5
+ b(c)-5 b(ks)56 b(with)i(side)f(exits.)78 b(Changes)57
+ b(m)-5 b(ust)57 b(b)5 b(e)58 b(made)f(to)g(mak)-5 b(e)57
+ b(sure)h(the)f(side)g(exits)0 9853 y(are)k(handled)e(prop)5
+ b(erly)-15 b(.)282 10218 y(Figure)66 b(5.2)g(sho)-5 b(ws)67
+ b(the)f(lo)5 b(op)67 b(reconstruction)e(algorithm)g(for)h(sup)5
+ b(erblo)g(c)-5 b(k)66 b(lo)5 b(ops.)99 b(Lines)65 b(1-30)h(are)h(iden-)
+ 0 10584 y(tical)f(to)g(the)h(standard)g(implemen)-5 b(tation,)65
+ b(but)i(the)f(prologue,)i(epilogue,)f(and)g(the)g(k)-5
+ b(ernel)66 b(are)h(one)g(or)h(more)3809 11136 y(52)p
+ eop end
+ %%Page: 53 60
+ TeXDict begin 53 59 bop 1206 219 a Fs(1)196 b Fm(maxS)8
+ b(tag)d(e)45 b Fs(=)52 b(maxim)l(um)f(stage)f(in)h(k)l(ernel)1206
+ 402 y(2)196 b Fm(P)21 b(r)t(ol)r(og)5 b(ue)46 b Fs(=)51
+ b(list)f(of)h(prologue)g(sup)t(erblo)t(c)l(ks)1206 584
+ y(3)196 b Fm(E)9 b(pil)r(og)c(ue)43 b Fs(=)52 b(list)e(of)h(epilogue)g
+ (sup)t(erblo)t(c)l(ks)1206 767 y(4)196 b Fm(k)t(er)t(nel)r(B)7
+ b(B)52 b Fs(=)g(new)g(k)l(ernel)f(sup)t(erblo)t(c)l(k)1206
+ 950 y(5)1206 1132 y(6)196 b(for\()p Fm(i)41 b Fs(=)i(0;)51
+ b Fm(i)42 b(<)p Fs(=)i Fm(maxS)8 b(tag)d(e)p Fs(;)54
+ b(++)p Fm(i)p Fs(\))269 b(//Create)51 b(Prologue)1206
+ 1315 y(7)358 b Fm(B)7 b(B)51 b Fs(=)g(new)h(sup)t(erblo)t(c)l(k)1206
+ 1498 y(8)358 b(for\()p Fm(j)50 b Fs(=)43 b Fm(i)p Fs(;)51
+ b Fm(j)g(>)p Fs(=)43 b(0;)51 b Fn(\000)35 b(\000)f Fm(j)9
+ b Fs(\))1206 1680 y(9)520 b Fn(8)p Fm(n)51 b Fs(instructions)f(in)h
+ (the)h(sup)t(erblo)t(c)l(k)1206 1863 y(10)605 b(if)51
+ b(\()p Fm(n)42 b Fn(2)51 b Fs(k)l(ernel)h(at)f(stage)f
+ Fm(j)9 b Fs(\))1206 2046 y(11)767 b(BB.add\(n\))1206
+ 2228 y(12)g(if)51 b(\()p Fm(n)f Fs(de\014nes)j(v)-9 b(alue)52
+ b(used)f(in)h(k)l(ernel)f(at)g(later)g(stage\))1206 2411
+ y(13)929 b(BB.add\(cop)l(y)51 b(v)-9 b(alue)52 b(instruction\))1206
+ 2594 y(14)281 b(Prologue.add\(BB\))1206 2776 y(15)1206
+ 2959 y(16)119 b(for\()p Fm(i)41 b Fs(=)i Fm(maxS)8 b(tag)d(e)37
+ b Fn(\000)e Fs(1;)51 b Fm(i)42 b(>)p Fs(=)i(0;)50 b({)p
+ Fm(i)p Fs(\))166 b(//Create)51 b(Epilogue)1206 3142 y(17)281
+ b Fm(B)7 b(B)51 b Fs(=)g(new)h(sup)t(erblo)t(c)l(k)1206
+ 3324 y(18)281 b(for\()p Fm(j)50 b Fs(=)43 b Fm(maxS)8
+ b(tag)d(e)p Fs(;)54 b Fm(j)d(>)43 b(i)p Fs(;)51 b({)p
+ Fm(j)9 b Fs(\))1206 3507 y(19)443 b Fn(8)p Fm(n)51 b
+ Fs(instructions)f(in)h(the)h(sup)t(erblo)t(c)l(k)1206
+ 3689 y(20)605 b(if)51 b(\()p Fm(n)42 b Fn(2)51 b Fs(k)l(ernel)h(at)f
+ (stage)f Fm(j)9 b Fs(\))1206 3872 y(21)767 b(up)t(date)52
+ b(n)g(to)f(use)g(correct)h(op)t(erand)g(v)-9 b(alues)1206
+ 4055 y(22)767 b(BB.add\(n\))1206 4237 y(23)281 b(Epilogue.add\(BB\))
+ 1206 4420 y(24)1206 4603 y(25)119 b Fn(8)p Fm(n)51 b
+ Fs(instructions)f Fn(2)i Fs(k)l(ernel)833 b(//Create)51
+ b(Kernel)1206 4785 y(26)281 b(if)51 b(\()p Fm(n)42 b
+ Fn(2)51 b Fs(k)l(ernel)h(at)f Fm(stag)5 b(e)44 b(>)f
+ Fs(0\))1206 4968 y(27)443 b(up)t(date)52 b(n)g(to)e(use)i(correct)g(op)
+ t(erand)g(v)-9 b(alues)1206 5151 y(28)281 b(if)51 b(\()p
+ Fm(n)f Fs(de\014nes)i(v)-9 b(alue)52 b(used)g(in)f(k)l(ernel)h(at)f
+ (later)f(stage\))1206 5333 y(29)443 b(BB.add\(cop)l(y)51
+ b(v)-9 b(alue)51 b(instruction\))1206 5516 y(30)1206
+ 5699 y(31)119 b Fn(8)p Fm(sideE)9 b(xits)49 b Fn(2)j
+ Fs(the)g(sup)t(erblo)t(c)l(k)1206 5881 y(32)281 b Fm(sideE)9
+ b(xitB)e(l)r(ock)47 b Fs(=)52 b(new)g(basic)e(blo)t(c)l(k)1206
+ 6064 y(33)281 b Fn(8)p Fm(n)51 b Fs(instructions)f(mo)l(v)l(ed)h(b)t
+ (elo)l(w)h(this)e(side)h(exit)1206 6247 y(34)443 b(if)51
+ b(\()p Fm(n)42 b Fn(2)51 b Fs(k)l(ernel)h(at)f(stage)f(0\))1206
+ 6429 y(34)605 b(sideExitBlo)t(c)l(k.add\(n\))1206 6612
+ y(35)281 b Fm(sideE)9 b(pil)r(og)c(ue)43 b Fs(=)51 b(clone)h(epilogue)
+ 1206 6795 y(36)281 b(up)t(date)52 b(last)e(branc)l(h)i(in)f(epilogue)h
+ (to)e(branc)l(h)i(to)f Fm(sideE)9 b(xitB)e(l)r(ock)1206
+ 6977 y Fs(37)281 b(up)t(date)52 b Fm(sideE)9 b(xitB)e(l)r(ock)56
+ b Fs(to)51 b(branc)l(h)h(to)f(original)f(lo)t(op)h(exit)1206
+ 7160 y(38)1206 7342 y(39)119 b Fn(8)p Fm(b)51 b Fn(2)h
+ Fm(P)21 b(r)t(ol)r(og)5 b(ue)1474 b Fs(//Up)t(date)51
+ b(Prologue)g(Branc)l(hes)1206 7525 y(41)281 b(if)51 b(\()p
+ Fm(b)f Fs(is)h(not)g(a)g(side)g(exit\))1206 7708 y(42)443
+ b(up)t(date)52 b(branc)l(h)g(to)f(correct)h(sup)t(erblo)t(c)l(k)g(in)f
+ (cloned)h(epilogue)f(for)g(this)g(side)g(exit)1206 7890
+ y(43)281 b(else)1206 8073 y(44)443 b(if)51 b(\()p Fm(b)f
+ Fs(not)h(last)f Fn(2)i Fm(P)21 b(r)t(ol)r(og)5 b(ue)p
+ Fs(\))1206 8256 y(45)605 b(up)t(date)52 b(branc)l(h)g(to)f(branc)l(h)h
+ (to)f(correct)g(sup)t(erblo)t(c)l(k)i(in)e(epilogue/prologue)1206
+ 8438 y(46)443 b(else)1206 8621 y(47)605 b(up)t(date)52
+ b(branc)l(h)g(to)f(branc)l(h)h(to)f(k)l(ernel/epilogue)1206
+ 8804 y(48)1206 8986 y(49)119 b Fn(8)p Fm(b)51 b Fn(2)h
+ Fm(E)9 b(pil)r(og)c(ue)1488 b Fs(//Up)t(date)51 b(Epilogue)g(Branc)l
+ (hes)1206 9169 y(50)281 b(if)51 b(\()p Fm(b)f Fs(not)h(last)f
+ Fn(2)i Fm(E)9 b(pil)r(og)c(ue)p Fs(\))1206 9352 y(51)443
+ b(c)l(hange)52 b(branc)l(h)g(to)e(unconditional)i(branc)l(h)g(to)e
+ (next)i(sup)t(erblo)t(c)l(k)g(in)f(epilogue)1206 9534
+ y(52)281 b(else)1206 9717 y(53)443 b(c)l(hange)52 b(branc)l(h)g(to)e
+ (unconditional)i(branc)l(h)g(to)e(original)g(lo)t(op)h(exit)1206
+ 9900 y(54)1206 10082 y(55)119 b(Up)t(date)52 b(k)l(ernel)f(branc)l(h)h
+ (to)f(branc)l(h)h(to)f(k)l(ernel/epilogue)1206 10265
+ y(56)119 b(Up)t(date)52 b(program's)e(branc)l(h)i(to)f(original)f(lo)t
+ (op)h(to)g(branc)l(h)h(to)e(prologue)831 10785 y Fx(Figure)60
+ b(5.2:)80 b(Pseudo)59 b(Co)5 b(de)61 b(for)f(Lo)5 b(op)61
+ b(Reconstruction)d(Algorithm)h(for)i(Sup)5 b(erblo)g(c)-5
+ b(ks)3809 11136 y(53)p eop end
+ %%Page: 54 61
+ TeXDict begin 54 60 bop 0 183 a Fx(sup)5 b(erblo)g(c)-5
+ b(ks.)76 b(Lines)51 b(31-37)g(are)h(the)f(\014rst)h(steps)f(for)g
+ (handling)g(side)g(exits.)76 b(F)-15 b(or)51 b(eac)-5
+ b(h)52 b(side)f(exit)g(in)g(the)h(original)0 548 y(sup)5
+ b(erblo)g(c)-5 b(k,)69 b(a)g(new)g Fu(Side)f(Exit)g(Blo)5
+ b(c)-5 b(k)67 b Fx(is)h(created.)104 b(Instructions)67
+ b(mo)-5 b(v)g(ed)68 b(b)5 b(elo)-5 b(w)68 b(this)g(side)g(exit)f(are)i
+ (placed)0 913 y(in)-5 b(to)70 b(the)g(new)h(basic)f(blo)5
+ b(c)-5 b(k.)109 b(Because)70 b(the)g(epilogue)f(\014nishes)h(an)-5
+ b(y)70 b(iterations)f(that)h(are)h(in)f(\015igh)-5 b(t,)72
+ b(the)e(side)0 1279 y(exit)d(blo)5 b(c)-5 b(k)67 b(only)h(includes)e
+ (instructions)g(from)h(the)h(curren)-5 b(t)67 b(iteration)g(\(stage)g
+ (0\).)102 b(Second,)69 b(the)e(epilogue)g(is)0 1644 y(cloned)d(and)g
+ (the)g(last)f(sup)5 b(erblo)g(c)-5 b(k's)63 b(branc)-5
+ b(h)64 b(in)g(the)g(epilogue)f(is)h(up)5 b(dated)64 b(to)g(branc)-5
+ b(h)65 b(to)f(the)g(new)g(side)g(exit)0 2010 y(blo)5
+ b(c)-5 b(k.)86 b(An)63 b(unconditional)d(branc)-5 b(h)63
+ b(is)f(added)g(to)g(the)g(side)g(exit)g(blo)5 b(c)-5
+ b(k)62 b(to)g(branc)-5 b(h)62 b(to)h(the)f(original)f(lo)5
+ b(op)62 b(exit)0 2375 y(in)e(the)g(program.)282 2740
+ y(Once)96 b(the)f(side)g(exit)g(and)h(corresp)5 b(onding)95
+ b(side)f(exit)h(epilogues)f(ha)-5 b(v)g(e)96 b(b)5 b(een)95
+ b(created,)103 b(the)96 b(prologue)0 3106 y(branc)-5
+ b(hes)54 b(m)-5 b(ust)53 b(b)5 b(e)53 b(up)5 b(dated.)78
+ b(Lines)53 b(39-48,)h(up)5 b(date)54 b(the)f(side)g(exit)h(branc)-5
+ b(hes)53 b(in)h(the)f(prologue)h(to)f(branc)-5 b(h)54
+ b(to)0 3471 y(the)65 b(corresp)5 b(onding)64 b(epilogue)g(for)h(eac)-5
+ b(h)65 b(side)f(exit.)94 b(The)65 b(last)g(branc)-5 b(h)65
+ b(of)g(eac)-5 b(h)65 b(sup)5 b(erblo)g(c)-5 b(k)64 b(in)h(the)g
+ (prologue)0 3836 y(either)58 b(branc)-5 b(hes)58 b(to)g(the)g(next)g
+ (sup)5 b(erblo)g(c)-5 b(k)58 b(in)g(the)g(prologue)g(or)h(the)f(k)-5
+ b(ernel.)79 b(Other)58 b(branc)-5 b(h)59 b(up)5 b(dates)58
+ b(\(Lines)0 4202 y(49-56\))i(require)g(no)g(c)-5 b(hanges)60
+ b(from)g(the)g(original)f(algorithm.)282 4567 y(Once)49
+ b(the)g(sup)5 b(erblo)g(c)-5 b(k)48 b(lo)5 b(op)48 b(has)h(b)5
+ b(een)49 b(reconstructed,)g(the)g(Swing)g(Mo)5 b(dulo)48
+ b(Sc)-5 b(heduling)48 b(for)g(sup)5 b(erblo)g(c)-5 b(ks)0
+ 4933 y(pass)60 b(is)g(complete.)0 5690 y Ft(5.4)270 b(Sup)7
+ b(erblo)g(c)-7 b(k)91 b(Lo)7 b(op)91 b(Example)0 6236
+ y Fx(T)-15 b(o)53 b(understand)g(the)g(c)-5 b(hanges)52
+ b(made)g(to)h(the)g(original)e(Swing)i(Mo)5 b(dulo)53
+ b(Sc)-5 b(heduling)51 b(algorithm,)i(w)-5 b(e)53 b(detail)e(the)0
+ 6601 y(steps)64 b(for)g(a)h(simple)e(sup)5 b(erblo)g(c)-5
+ b(k)64 b(lo)5 b(op)64 b(example.)92 b(Figure)64 b(5.4)g(sho)-5
+ b(ws)65 b(the)f(C)h(and)g(LL)-20 b(VM)64 b(co)5 b(de)65
+ b(for)f(a)h(simple)0 6966 y(sup)5 b(erblo)g(c)-5 b(k)59
+ b(lo)5 b(op.)80 b(The)61 b(lo)5 b(op)60 b(computes)e(and)j(store)f(v)
+ -10 b(alues)59 b(for)h(t)-5 b(w)g(o)60 b(arra)-5 b(ys.)80
+ b(It)60 b(has)g(a)h(side)e(exit)h(in)g(the)g(lo)5 b(op)0
+ 7332 y(if)54 b(one)h(of)f(the)h(previous)f(arra)-5 b(y)55
+ b(v)-10 b(alues)54 b(is)h(less)e(than)i(some)f(v)-10
+ b(alue.)78 b(Note)55 b(that)f(this)g(lo)5 b(op)54 b(consists)g(of)g(t)
+ -5 b(w)g(o)55 b(basic)0 7697 y(blo)5 b(c)-5 b(ks,)68
+ b(a)g(single)f(en)-5 b(try)67 b(\(aside)g(from)g(the)g(bac)-5
+ b(k)68 b(edge\),)h(and)e(one)h(side)f(exit.)101 b(Figure)68
+ b(5.4)f(sho)-5 b(ws)67 b(the)h(LL)-20 b(VM)0 8062 y(Mac)-5
+ b(hine)50 b(co)5 b(de)52 b(for)f(our)h(example)e(sup)5
+ b(erblo)g(c)-5 b(k)51 b(lo)5 b(op.)77 b(Recall)50 b(that)h(this)f(mac)
+ -5 b(hine)51 b(co)5 b(de)51 b(closely)f(resem)-5 b(bles)49
+ b(the)0 8428 y(SP)-15 b(AR)-5 b(C)61 b(V9)g(assem)-5
+ b(bly)-15 b(.)282 8793 y(The)53 b(\014rst)f(step)f(is)h(to)f(construct)
+ h(the)f(Data)h(Dep)5 b(endence)51 b(Graph)h(for)g(the)g(instructions)e
+ (that)i(mak)-5 b(e)51 b(up)h(the)0 9159 y(b)5 b(o)g(dy)54
+ b(of)g(the)f(lo)5 b(op.)78 b(Figure)53 b(5.5)g(is)h(the)f(DDG)h(for)g
+ (our)g(example)f(sup)5 b(erblo)g(c)-5 b(k)53 b(lo)5 b(op.)77
+ b(The)55 b(\014rst)e(thing)h(to)f(notice)0 9524 y(is)66
+ b(that)h(the)f(conditional)f(branc)-5 b(h)67 b(instructions)e(\(n13,)j
+ (n14,)g(n15\))f(ha)-5 b(v)g(e)66 b(b)5 b(een)67 b(represen)-5
+ b(ted)66 b(b)-5 b(y)67 b(a)g(PredNo)5 b(de)0 9889 y(no)g(de)54
+ b(for)g(the)f(no)p 1214 9889 55 7 v 66 w(exit)g(basic)g(blo)5
+ b(c)-5 b(k.)77 b(The)54 b(dep)5 b(endences)53 b(b)5 b(et)-5
+ b(w)g(een)54 b(the)f(instructions)f(it)h(represen)-5
+ b(ts)53 b(and)h(other)0 10255 y(instructions)k(in)j(the)f(lo)5
+ b(op)60 b(b)5 b(o)g(dy)60 b(ha)-5 b(v)g(e)60 b(b)5 b(een)61
+ b(preserv)-5 b(ed.)282 10620 y(While)64 b(the)g(ma)10
+ b(jorit)-5 b(y)63 b(of)h(the)g(dep)5 b(endencies)63 b(b)5
+ b(et)-5 b(w)g(een)64 b(the)g(instructions)e(are)j(created)e(as)i
+ (normal,)f(a)g(few)3809 11136 y(54)p eop end
+ %%Page: 55 62
+ TeXDict begin 55 61 bop 14 1472 a Fi(f)14 b(o)g(r)29
+ b Fo(\()37 b(i)113 b(=)89 b(1)21 b(;)111 b(i)102 b Fh(<)67
+ b Fo(5)10 b(0)g(0)g(;)69 b(+)10 b(+)33 b(i)43 b(\))88
+ b Fg(f)162 1630 y Fo(B)15 b([)45 b(i)e(])85 b(=)78 b(B)15
+ b([)38 b(i)50 b Fg(\000)20 b Fo(1)g(])86 b Fg(\003)g
+ Fo(3)20 b(.)g(2)39 b(f)44 b(;)194 1787 y Fi(i)25 b(f)40
+ b Fo(\()t(A)12 b([)38 b(i)45 b Fg(\000)14 b Fo(1)g(])90
+ b Fh(<)76 b Fo(4)14 b(.)g(5)35 b(f)h(\))258 1945 y Fi(b)t(r)t(e)t(a)t
+ (k)29 b Fo(;)159 2103 y(A)12 b([)45 b(i)e(])85 b(=)75
+ b(A)12 b([)38 b(i)50 b Fg(\000)20 b Fo(1)g(])86 b Fg(\003)g
+ Fo(3)20 b(.)g(4)39 b(f)44 b(;)7 2261 y Fg(g)528 2586
+ y Fx(\(a\))60 b(C)h(Co)5 b(de)2287 210 y Fo(n)20 b(o)p
+ 2485 210 43 7 v 92 w(e)g(x)g(i)g(t)44 b(:)2589 368 y(\045)o(i)16
+ b(n)g(d)g(v)g(a)g(r)90 b(=)79 b Fi(p)7 b(h)g(i)102 b(u)10
+ b(i)g(n)g(t)99 b Fo([)89 b(0)40 b(,)89 b(\045)36 b(e)16
+ b(n)g(t)g(r)g(y)113 b(])49 b(,)95 b([)g(\045)47 b(i)42
+ b(.)19 b(0)g(.)g(0)36 b(,)85 b(\045)39 b(e)20 b(n)g(d)g(i)g(f)124
+ b(])2589 526 y(\045)6 b(i)44 b(.)21 b(0)g(.)g(0)90 b(=)d
+ Fi(a)o(d)o(d)94 b(u)10 b(i)g(n)g(t)61 b Fo(\045)15 b(i)f(n)g(d)g(v)g(a)
+ g(r)53 b(,)96 b(1)2589 683 y(\045)-16 b(t)q(m)q(p)19
+ b(.)f(6)84 b(=)95 b Fi(c)12 b(a)g(s)g(t)107 b(u)10 b(i)g(n)g(t)61
+ b Fo(\045)24 b(i)49 b(.)27 b(0)e(.)i(0)107 b Fi(t)8 b(o)102
+ b(l)8 b(o)g(n)g(g)2589 841 y Fo(\045)-16 b(t)q(m)q(p)19
+ b(.)f(7)84 b(=)90 b Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)
+ g(r)105 b Fo([)24 b(5)f(0)g(0)98 b(x)108 b Fi(f)17 b(l)g(o)g(a)g(t)33
+ b Fo(])13 b Fg(\003)72 b Fo(\045)s(T)-10 b(M)g(P)g(2)8
+ b(,)111 b Fi(l)8 b(o)g(n)g(g)101 b Fo(0)45 b(,)100 b
+ Fi(l)8 b(o)g(n)g(g)60 b Fo(\045)r(t)q(m)q(p)20 b(.)g(6)2589
+ 999 y(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(0)81 b(=)95 b
+ Fi(c)12 b(a)g(s)g(t)107 b(u)10 b(i)g(n)g(t)61 b Fo(\045)17
+ b(i)f(n)g(d)g(v)g(a)g(r)110 b Fi(t)8 b(o)102 b(l)8 b(o)g(n)g(g)2589
+ 1156 y Fo(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(1)81 b(=)90
+ b Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)g(r)105
+ b Fo([)24 b(5)f(0)f(0)99 b(x)107 b Fi(f)17 b(l)g(o)g(a)g(t)33
+ b Fo(])13 b Fg(\003)73 b Fo(\045)r(T)-10 b(M)g(P)g(2)9
+ b(,)110 b Fi(l)8 b(o)g(n)g(g)102 b Fo(0)45 b(,)100 b
+ Fi(l)8 b(o)g(n)g(g)60 b Fo(\045)r(t)q(m)q(p)18 b(.)g(1)g(0)2589
+ 1314 y(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(2)81 b(=)91
+ b Fi(l)9 b(o)g(a)g(d)110 b(f)17 b(l)g(o)g(a)g(t)25 b
+ Fg(\003)56 b Fo(\045)5 b(t)q(m)q(p)19 b(.)f(1)g(1)2589
+ 1472 y(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(3)81 b(=)d Fi(m)l(u)l(l)98
+ b(f)17 b(l)g(o)g(a)g(t)70 b Fo(\045)r(t)q(m)q(p)16 b(.)f(1)g(2)31
+ b(,)78 b(\045)8 b(F)-7 b(P)g(V)g(A)g(L)g(2)2618 1630
+ y Fi(s)12 b(t)g(o)g(r)g(e)115 b(f)17 b(l)g(o)g(a)g(t)70
+ b Fo(\045)r(t)q(m)q(p)23 b(.)g(1)f(3)44 b(,)110 b Fi(f)17
+ b(l)g(o)g(a)g(t)24 b Fg(\003)56 b Fo(\045)5 b(t)q(m)q(p)21
+ b(.)f(7)2589 1787 y(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(7)81
+ b(=)90 b Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)g(r)105
+ b Fo([)24 b(5)f(0)f(0)99 b(x)107 b Fi(f)17 b(l)g(o)g(a)g(t)33
+ b Fo(])13 b Fg(\003)73 b Fo(\045)n(T)-15 b(M)g(P)o(,)111
+ b Fi(l)8 b(o)g(n)g(g)101 b Fo(0)45 b(,)100 b Fi(l)8 b(o)g(n)g(g)60
+ b Fo(\045)r(t)q(m)q(p)19 b(.)f(1)g(0)2589 1945 y(\045)-16
+ b(t)q(m)q(p)18 b(.)g(1)g(8)81 b(=)91 b Fi(l)9 b(o)g(a)g(d)110
+ b(f)17 b(l)g(o)g(a)g(t)25 b Fg(\003)56 b Fo(\045)5 b(t)q(m)q(p)19
+ b(.)f(1)g(7)2589 2103 y(\045)-16 b(t)q(m)q(p)18 b(.)g(1)g(9)81
+ b(=)101 b Fi(s)19 b(e)g(t)g(l)g(t)121 b(f)17 b(l)g(o)g(a)g(t)70
+ b Fo(\045)r(t)q(m)q(p)16 b(.)f(1)g(8)31 b(,)79 b(\045)8
+ b(F)-7 b(P)g(V)g(A)g(L)g(3)2610 2261 y Fi(b)t(r)97 b(b)8
+ b(o)g(o)g(l)60 b Fo(\045)r(t)q(m)q(p)22 b(.)h(1)f(9)44
+ b(,)107 b Fi(l)15 b(a)g(b)g(e)g(l)65 b Fo(\045)20 b(l)f(o)g(o)g(p)g(e)g
+ (x)g(i)g(t)63 b(,)118 b Fi(l)15 b(a)g(b)g(e)g(l)65 b
+ Fo(\045)21 b(e)f(n)g(d)g(i)g(f)2287 2576 y(e)g(n)g(d)g(i)g(f)45
+ b(:)2589 2734 y(\045)-16 b(t)q(m)q(p)18 b(.)g(2)g(3)81
+ b(=)90 b Fi(g)7 b(e)g(t)g(e)g(l)g(e)g(m)g(e)g(n)g(t)g(p)g(t)g(r)105
+ b Fo([)24 b(5)f(0)f(0)99 b(x)107 b Fi(f)17 b(l)g(o)g(a)g(t)33
+ b Fo(])13 b Fg(\003)73 b Fo(\045)n(T)-15 b(M)g(P)o(,)111
+ b Fi(l)8 b(o)g(n)g(g)101 b Fo(0)45 b(,)100 b Fi(l)8 b(o)g(n)g(g)60
+ b Fo(\045)r(t)q(m)q(p)20 b(.)g(6)2589 2892 y(\045)-16
+ b(t)q(m)q(p)18 b(.)g(2)g(9)81 b(=)d Fi(m)l(u)l(l)98 b(f)17
+ b(l)g(o)g(a)g(t)70 b Fo(\045)r(t)q(m)q(p)16 b(.)f(1)g(8)31
+ b(,)78 b(\045)5 b(F)-11 b(P)g(V)g(A)g(L)2618 3049 y Fi(s)12
+ b(t)g(o)g(r)g(e)115 b(f)17 b(l)g(o)g(a)g(t)70 b Fo(\045)r(t)q(m)q(p)23
+ b(.)g(2)f(9)44 b(,)110 b Fi(f)17 b(l)g(o)g(a)g(t)24 b
+ Fg(\003)56 b Fo(\045)5 b(t)q(m)q(p)19 b(.)f(2)g(3)2589
+ 3207 y(\045)r(i)g(n)g(c)92 b(=)70 b Fi(a)o(d)o(d)93 b(u)10
+ b(i)g(n)g(t)61 b Fo(\045)15 b(i)f(n)g(d)g(v)g(a)g(r)54
+ b(,)96 b(2)2589 3365 y(\045)-16 b(t)q(m)q(p)19 b(.)f(3)84
+ b(=)102 b Fi(s)19 b(e)g(t)g(l)g(t)113 b(u)10 b(i)g(n)g(t)61
+ b Fo(\045)16 b(i)f(n)g(c)50 b(,)89 b(5)21 b(0)g(0)2610
+ 3523 y Fi(b)t(r)97 b(b)8 b(o)g(o)g(l)60 b Fo(\045)r(t)q(m)q(p)24
+ b(.)g(3)47 b(,)110 b Fi(l)15 b(a)g(b)g(e)g(l)64 b Fo(\045)19
+ b(n)f(o)p 4765 3523 V 87 w(e)g(x)g(i)g(t)64 b(,)117 b
+ Fi(l)15 b(a)g(b)g(e)g(l)65 b Fo(\045)22 b(l)f(o)g(o)g(p)g(e)g(x)g(i)g
+ (t)4551 3848 y Fx(\(b\))60 b(LL)-20 b(VM)59 b(Co)5 b(de)2085
+ 4302 y(Figure)60 b(5.3:)79 b(Simple)59 b(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)60 b(Example)0 4852 y(are)68 b(added)f(to)h(con)-5
+ b(trol)66 b(up)-5 b(w)g(ard)68 b(and)g(do)-5 b(wn)g(w)g(ard)68
+ b(co)5 b(de)68 b(motion.)100 b(Because)66 b(there)i(are)f(no)h
+ (instructions)e(that)0 5217 y(are)56 b(liv)-5 b(e)55
+ b(when)h(the)g(side)f(exit)g(is)g(tak)-5 b(en,)56 b(no)g(lo)5
+ b(op-carried)54 b(dep)5 b(endencies)55 b(b)5 b(et)-5
+ b(w)g(een)55 b(the)h(PredNo)5 b(de)56 b(and)g(those)0
+ 5583 y(instructions)62 b(are)i(created.)91 b(Second,)64
+ b(y)-5 b(ou)65 b(will)e(notice)g(that)g(there)h(are)g(dep)5
+ b(endencies)63 b(created)h(b)5 b(et)-5 b(w)g(een)63 b(the)0
+ 5948 y(PredNo)5 b(de)77 b(and)f(the)h(store)f(\(n22\),)j(and)e(the)f
+ (PredNo)5 b(de)77 b(and)g(the)f(fm)-5 b(uls)75 b(\(n19\).)128
+ b(Those)77 b(t)-5 b(w)g(o)76 b(instructions)0 6314 y(could)53
+ b(p)5 b(oten)-5 b(tially)52 b(cause)h(an)g(exception)g(and)h(alter)f
+ (the)g(original)f(b)5 b(eha)-5 b(vior)54 b(of)f(the)g(program.)78
+ b(Therefore,)54 b(the)0 6679 y(dep)5 b(endencies)59 b(are)i(created)g
+ (to)f(prev)-5 b(en)g(t)61 b(the)f(instructions)f(from)h(b)5
+ b(eing)61 b(mo)-5 b(v)g(ed)60 b(ab)5 b(o)-5 b(v)g(e)60
+ b(the)h(branc)-5 b(h)61 b(\(up)-5 b(w)g(ard)0 7044 y(co)5
+ b(de)60 b(motion\).)282 7410 y(Once)f(the)f(DDG)g(has)g(b)5
+ b(een)58 b(created,)g(the)g(MI)5 b(I)58 b(v)-10 b(alue)57
+ b(m)-5 b(ust)58 b(b)5 b(e)58 b(determined)f(b)-5 b(y)59
+ b(computing)e(the)h(ResMI)5 b(I)0 7775 y(and)46 b(RecMI)5
+ b(I)44 b(as)h(describ)5 b(ed)45 b(in)g(Section)f(4.3.)75
+ b(F)-15 b(or)45 b(our)h(sup)5 b(erblo)g(c)-5 b(k)45 b(lo)5
+ b(op)45 b(example)f(there)h(are)h(four)f(recurrences,)0
+ 8140 y(with)58 b(the)h(highest)f(RecMI)5 b(I)57 b(v)-10
+ b(alue)58 b(of)g(8.)80 b(This)58 b(is)h(from)f(the)g(recurrence)h
+ (consisting)e(of)h(the)g(st)h(\(n11\),)f(ld)g(\(n7\),)0
+ 8506 y(and)d(fm)-5 b(uls)54 b(\(n10\))h(and)g(also)g(from)f(the)h
+ (recurrence)g(consisting)e(of)i(PredNo)5 b(de,)56 b(ld)f(\(n12\),)g(fm)
+ -5 b(uls)54 b(\(n19\),)h(and)h(st)0 8871 y(\(n22\).)78
+ b(Because)56 b(these)g(recurrences)g(ha)-5 b(v)g(e)56
+ b(the)h(same)e(RecMI)5 b(I,)55 b(it)h(do)5 b(es)56 b(not)h(matter)e
+ (whic)-5 b(h)57 b(one)f(is)g(c)-5 b(hosen)56 b(as)0 9237
+ y(the)63 b(highest)e(RecMI)5 b(I.)61 b(Eac)-5 b(h)63
+ b(recurrence)g(has)g(a)g(total)e(latency)h(of)h(8)g(and)g(a)g(distance)
+ e(of)i(1,)g(whic)-5 b(h)63 b(results)e(in)0 9602 y(a)i(RecMI)5
+ b(I)62 b(of)h(8.)88 b(T)-15 b(able)63 b(5.1)f(sho)-5
+ b(ws)63 b(the)g(latencies)e(for)i(eac)-5 b(h)63 b(instruction.)86
+ b(Please)62 b(note)h(that)f(the)h(PredNo)5 b(de)0 9967
+ y(has)60 b(a)h(latency)e(of)h(3)h(b)5 b(ecause)59 b(that)h(is)g(the)g
+ (total)g(latency)f(of)h(all)g(the)g(instructions)e(is)i(represen)-5
+ b(ts.)282 10333 y(The)84 b(resource)e(usage)h(is)f(totaled)g(for)g(all)
+ g(instructions)f(in)i(the)f(lo)5 b(op)83 b(b)5 b(o)g(dy)-15
+ b(.)148 b(The)83 b(most)f(hea)-5 b(vily)81 b(used)3809
+ 11136 y(55)p eop end
+ %%Page: 56 63
+ TeXDict begin 56 62 bop 20 210 a Fo(n)20 b(o)p 218 210
+ 43 7 v 92 w(e)g(x)g(i)g(t)44 b(:)184 368 y(\()22 b(n)7
+ b(1)29 b(\))175 b Fi(a)o(d)o(d)49 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g
+ (0)109 b(i)16 b(n)g(d)g(v)g(a)g(r)39 b(:)28 b(P)5 b(h)g(i)g(C)g(p)19
+ b(\))27 b(,)74 b(\045)20 b(g)7 b(0)25 b(,)73 b(\045)28
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g(0)114 b(i)16 b(n)g(d)g(v)g(a)g(r)32
+ b(\))184 526 y(\()22 b(n)7 b(2)29 b(\))175 b Fi(a)o(d)o(d)49
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)32
+ b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g(0)114 b(i)16
+ b(n)g(d)g(v)g(a)g(r)34 b(\))i(,)82 b(1)35 b(,)83 b(\045)34
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101 b(m)6 b(a)g(s)g(k)g(H)g(i)22
+ b(\))184 683 y(\()g(n)7 b(3)29 b(\))175 b Fi(a)o(d)o(d)49
+ b Fo(\045)8 b(g)f(0)26 b(,)72 b(\045)29 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)114 b(i)16 b(n)g(d)g(v)g(a)g(r)30 b(\))d(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100 b(t)q(m)q(p)21
+ b(.)g(1)g(0)g(\))184 841 y(\()h(n)7 b(4)29 b(\))201 b
+ Fi(s)25 b(l)g(l)76 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)99
+ b(t)q(m)q(p)20 b(.)f(1)g(0)g(\))39 b(,)86 b(2)38 b(,)86
+ b(\045)35 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28
+ b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(2)g(0)22 b(\))184
+ 999 y(\()g(n)7 b(5)29 b(\))201 b Fi(s)25 b(l)g(l)76 b
+ Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)99 b(t)q(m)q(p)20
+ b(.)f(1)g(0)g(\))39 b(,)86 b(2)38 b(,)86 b(\045)35 b(r)16
+ b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(d)g
+ (7)g(5)g(c)g(0)23 b(\))184 1156 y(\()f(n)7 b(6)29 b(\))196
+ b Fi(s)19 b(r)g(l)71 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))36 b(,)82 b(0)35 b(,)83
+ b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)122 b(i)48
+ b(.)25 b(0)f(.)h(0)g(\))184 1314 y(\()d(n)7 b(7)29 b(\))188
+ b Fi(l)11 b(d)62 b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)30 b(x)14 b(1)g(0)g(0)g(c)g(5)g(4)g(7)g(e)g(0)83
+ b(T)-12 b(M)g(P)g(2)r(\))27 b(,)73 b(\045)30 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(c)g
+ (0)22 b(\))k(,)74 b(\045)30 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g(0)99
+ b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))184 1472 y(\()h(n)7 b(8)29
+ b(\))175 b Fi(a)o(d)o(d)49 b Fo(\045)8 b(g)f(0)26 b(,)72
+ b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)122 b(i)43
+ b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g
+ (0)100 b(t)q(m)q(p)22 b(.)h(6)f(\))184 1630 y(\()g(n)7
+ b(9)29 b(\))201 b Fi(s)25 b(l)g(l)76 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g
+ (0)99 b(t)q(m)q(p)20 b(.)g(6)g(\))39 b(,)87 b(2)39 b(,)86
+ b(\045)36 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(2)g(0)25 b(\))184
+ 1787 y(\()f(n)9 b(1)g(0)30 b(\))106 b(f)15 b(m)g(u)g(l)g(s)65
+ b(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)30
+ b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g(0)98 b(t)q(m)q(p)17
+ b(.)g(1)g(2)g(\))34 b(,)81 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(6)g(b)g
+ (0)92 b(F)-7 b(P)g(V)g(A)g(L)g(2)5 b(\))26 b(,)74 b(\045)30
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)14
+ b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)96 b(t)q(m)q(p)21
+ b(.)g(1)g(3)g(\))184 1945 y(\()j(n)9 b(1)g(1)30 b(\))105
+ b Fi(s)14 b(t)65 b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)30 b(x)14 b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)96
+ b(t)q(m)q(p)17 b(.)g(1)g(3)g(\))34 b(,)81 b(\045)33 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(c)g(5)g
+ (4)g(7)g(e)g(0)83 b(T)-12 b(M)g(P)g(2)q(\))27 b(,)74
+ b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(2)g(0)25 b(\))184
+ 2103 y(\()f(n)9 b(1)g(2)30 b(\))103 b Fi(l)11 b(d)62
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)30
+ b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(3)g(0)78 b(T)-18
+ b(M)g(P)-6 b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(2)g
+ (0)20 b(\))27 b(,)73 b(\045)30 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97
+ b(t)q(m)q(p)21 b(.)g(1)g(8)g(\))184 2261 y(\()j(n)9 b(1)g(3)16
+ b(\))64 b(\045)26 b(c)18 b(c)g(r)g(e)g(g)33 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g(0)25
+ b(\))78 b(=)90 b(f)11 b(c)g(m)g(p)g(s)61 b(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g
+ (0)98 b(t)q(m)q(p)17 b(.)g(1)g(8)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(8)g(7)g(3)g(0)89 b(F)-7 b(P)g(V)g(A)g(L)g(3)6
+ b(\))184 2418 y(\()24 b(n)9 b(1)g(4)30 b(\))115 b(f)23
+ b(b)h(l)74 b(\045)19 b(c)f(c)g(r)g(e)g(g)33 b(\()f(v)17
+ b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g(0)22
+ b(\))k(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)35 b(\()i(l)22
+ b(a)g(b)g(e)g(l)128 b(l)21 b(o)g(o)g(p)g(e)g(x)g(i)g(t)35
+ b(\))184 2576 y(\()24 b(n)9 b(1)g(5)30 b(\))91 b Fi(ba)51
+ b Fo(\045)19 b(d)e(i)g(s)g(p)34 b(\()j(l)22 b(a)g(b)h(e)f(l)127
+ b(e)20 b(n)g(d)g(i)g(f)37 b(\))20 2892 y(e)20 b(n)g(d)g(i)g(f)184
+ 3049 y(\()k(n)9 b(1)g(6)30 b(\))90 b Fi(a)o(d)o(d)49
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)121 b(i)43
+ b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)27 b(g)7 b(0)26
+ b(,)72 b(\045)29 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g(0)109
+ b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(:)28 b(P)5 b(h)g(i)g(C)g(p)20
+ b(\))184 3207 y(\()k(n)9 b(1)g(7)30 b(\))116 b Fi(s)25
+ b(l)g(l)76 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)30 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g(0)99
+ b(t)q(m)q(p)20 b(.)g(6)g(\))39 b(,)87 b(2)39 b(,)86 b(\045)36
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10
+ b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(3)g(0)28 b(\))184 3365
+ y(\()c(n)9 b(1)g(8)30 b(\))90 b Fi(a)o(d)o(d)49 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g(0)114 b(i)16 b(n)g(d)g(v)g(a)g(r)34
+ b(\))i(,)82 b(2)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g
+ (0)106 b(m)6 b(a)g(s)g(k)g(H)g(i)22 b(\))184 3523 y(\()i(n)9
+ b(1)g(9)30 b(\))106 b(f)15 b(m)g(u)g(l)g(s)65 b(\045)18
+ b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97 b(t)q(m)q(p)17
+ b(.)g(1)g(8)g(\))34 b(,)81 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(6)g(3)g
+ (0)86 b(F)-11 b(P)g(V)g(A)g(L)s(\))27 b(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(9)g(4)g(9)g(0)97 b(t)q(m)q(p)21
+ b(.)g(2)g(9)g(\))184 3680 y(\()j(n)9 b(2)g(0)30 b(\))111
+ b Fi(s)19 b(r)g(l)71 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g(0)105
+ b(m)6 b(a)g(s)g(k)g(H)g(i)25 b(\))36 b(,)82 b(0)35 b(,)83
+ b(\045)34 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g(0)118 b(i)18
+ b(n)g(c)34 b(\))184 3838 y(\()24 b(n)9 b(2)g(1)30 b(\))97
+ b Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()h(v)17 b(a)g(l)101 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g
+ (0)117 b(i)18 b(n)g(c)37 b(\))d(,)82 b(5)17 b(0)g(0)33
+ b(,)81 b(\045)24 b(g)7 b(0)26 b(,)72 b(\045)31 b(c)18
+ b(c)g(r)g(e)g(g)33 b(\()f(v)17 b(a)g(l)100 b(0)27 b(x)10
+ b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(d)g(0)21 b(\))184 3996
+ y(\()j(n)9 b(2)g(2)30 b(\))105 b Fi(s)14 b(t)65 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(9)g(4)g(9)g(0)97 b(t)q(m)q(p)17
+ b(.)g(2)g(9)g(\))34 b(,)81 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(3)g
+ (0)78 b(T)-18 b(M)g(P)-5 b(\))26 b(,)74 b(\045)30 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g
+ (7)g(d)g(3)g(0)27 b(\))184 4154 y(\()d(n)9 b(2)g(3)30
+ b(\))106 b(b)14 b(c)g(s)65 b(\045)19 b(c)f(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)101 b(0)26 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(d)g
+ (0)20 b(\))26 b(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)35
+ b(\()i(l)22 b(a)g(b)g(e)g(l)128 b(n)20 b(o)p 4368 4154
+ V 91 w(e)g(x)g(i)g(t)36 b(\))184 4311 y(\()24 b(n)9 b(2)g(4)30
+ b(\))91 b Fi(ba)51 b Fo(\045)19 b(d)e(i)g(s)g(p)34 b(\()j(l)22
+ b(a)g(b)h(e)f(l)128 b(l)21 b(o)g(o)g(p)g(e)g(x)g(i)g(t)34
+ b(\))1662 4803 y Fx(Figure)60 b(5.4:)79 b(LL)-20 b(VM)60
+ b(Mac)-5 b(hine)59 b(Co)5 b(de)61 b(for)f(a)h(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)0 5353 y(resource)43 b(is)f(the)g(in)-5
+ b(teger)42 b(unit)h(\(15)f(uses\).)74 b(Because)41 b(there)i(are)g(t)-5
+ b(w)g(o)43 b(of)f(this)g(resource,)k(the)d(ResMI)5 b(I)41
+ b(is)h(computed)0 5718 y(to)55 b(b)5 b(e)55 b(8.)79 b(The)55
+ b(maxim)-5 b(um)54 b(of)g(ResMI)5 b(I)54 b(\(8\))h(and)g(RecMI)5
+ b(I)54 b(\(8\))h(is)g(used)g(for)g(MI)5 b(I,)54 b(whic)-5
+ b(h)55 b(means)f(that)h(MI)5 b(I)54 b(is)h(set)0 6084
+ y(to)60 b(8.)282 6449 y(The)50 b(next)f(phase)g(of)g(the)g(extended)g
+ (Mo)5 b(dulo)49 b(Sc)-5 b(heduling)48 b(algorithm)g(is)h(to)g
+ (calculate)e(the)i(v)-10 b(arious)49 b(prop)5 b(er-)0
+ 6814 y(ties)52 b(for)i(eac)-5 b(h)53 b(no)5 b(de.)78
+ b(These)53 b(prop)5 b(erties)53 b(are)h(used)f(to)g(order)h(the)f(no)5
+ b(des)53 b(for)h(sc)-5 b(heduling.)76 b(The)54 b(ASAP)-15
+ b(,)54 b(ALAP)-15 b(,)0 7180 y(MOB,)62 b(Heigh)-5 b(t,)62
+ b(and)g(Depth)g(\(describ)5 b(ed)61 b(in)h(Section)f(4.3\))h(are)g
+ (computed)f(for)i(eac)-5 b(h)62 b(no)5 b(de)62 b(in)g(the)g(DDG.)f(F)
+ -15 b(or)0 7545 y(these)61 b(calculations)f(one)i(bac)-5
+ b(k)62 b(edge)f(\(do)5 b(esn't)61 b(matter)g(whic)-5
+ b(h)62 b(one\))g(is)f(ignored)h(in)f(order)i(to)f(a)-5
+ b(v)g(oid)61 b(endlessly)0 7911 y(cycling)81 b(in)g(the)h(graph.)144
+ b(T)-15 b(able)82 b(5.2)f(sho)-5 b(ws)81 b(the)h(no)5
+ b(de)82 b(attributes)e(for)i(this)f(example.)143 b(The)82
+ b(PredNo)5 b(de)82 b(is)0 8276 y(treated)60 b(lik)-5
+ b(e)59 b(an)-5 b(y)61 b(other)f(no)5 b(de)60 b(for)g(these)g
+ (calculations.)p 1885 8650 3978 7 v 1882 8833 7 183 v
+ 1985 8778 a Fs(No)t(de)p 3389 8833 V 1158 w(Latency)p
+ 4124 8833 V 4157 8833 V 233 w(No)t(de)p 5125 8833 V 619
+ w(Latency)p 5860 8833 V 1885 8839 3978 7 v 1882 9022
+ 7 183 v 1985 8967 a(PredNo)t(de)52 b(\(no)p 2935 8967
+ 47 7 v 56 w(exit\))p 3389 9022 7 183 v 657 w(1)p 4124
+ 9022 V 4157 9022 V 232 w(add)g(\(n3\))p 5125 9022 V 846
+ w(3)p 5860 9022 V 1882 9205 V 1985 9150 a(sll)e(\(n4\))p
+ 3389 9205 V 1487 w(1)p 4124 9205 V 4157 9205 V 232 w(sll)g(\(n5\))p
+ 5125 9205 V 948 w(1)p 5860 9205 V 1882 9387 V 1985 9332
+ a(ld)h(\(n7\))p 3389 9387 V 1505 w(3)p 4124 9387 V 4157
+ 9387 V 232 w(add)h(\(n8\))p 5125 9387 V 846 w(1)p 5860
+ 9387 V 1882 9570 V 1985 9515 a(sll)e(\(n9\))p 3389 9570
+ V 1487 w(1)p 4124 9570 V 4157 9570 V 232 w(fm)l(uls)h(\(n10\))p
+ 5125 9570 V 657 w(4)p 5860 9570 V 1882 9753 V 1985 9698
+ a(st)g(\(n11\))p 3389 9753 V 1435 w(1)p 4124 9753 V 4157
+ 9753 V 232 w(ld)g(\(n12\))p 5125 9753 V 889 w(3)p 5860
+ 9753 V 1882 9935 V 1985 9880 a(sll)f(\(n17\))p 3389 9935
+ V 1410 w(1)p 4124 9935 V 4157 9935 V 232 w(fm)l(uls)h(\(n19\))p
+ 5125 9935 V 657 w(4)p 5860 9935 V 1882 10118 V 1985 10063
+ a(st)g(\(n22\))p 3389 10118 V 1435 w(1)p 4124 10118 V
+ 4157 10118 V 5125 10118 V 5860 10118 V 1885 10124 3978
+ 7 v 1815 10516 a Fx(T)-15 b(able)60 b(5.1:)79 b(No)5
+ b(de)61 b(Latencies)e(for)h(Simple)f(Lo)5 b(op)60 b(Example)3809
+ 11136 y(56)p eop end
+ %%Page: 57 64
+ TeXDict begin 57 63 bop 0 408 a
+  29246476 21642385 2302361 2302361 44402688 33746042 startTexFig
+  0 408 a
+ %%BeginDocument: figs/ESMS-DepGraph.ps
+ %!PS-Adobe-2.0
+ %%Creator: dot version 1.9 (Thu Feb 13 13:41:01 CST 2003)
+ %%For: (tbrethou) Tanya Brethour
+ %%Title: foo
+ %%Pages: (atend)
+ %%BoundingBox: 35 35 675 513
+ %%EndComments
+ save
+ %%BeginProlog
+ /DotDict 200 dict def
+ DotDict begin
+ 
+ /setupLatin1 {
+ mark
+ /EncodingVector 256 array def
+  EncodingVector 0
+ 
+ ISOLatin1Encoding 0 255 getinterval putinterval
+ 
+ EncodingVector
+   dup 306 /AE
+   dup 301 /Aacute
+   dup 302 /Acircumflex
+   dup 304 /Adieresis
+   dup 300 /Agrave
+   dup 305 /Aring
+   dup 303 /Atilde
+   dup 307 /Ccedilla
+   dup 311 /Eacute
+   dup 312 /Ecircumflex
+   dup 313 /Edieresis
+   dup 310 /Egrave
+   dup 315 /Iacute
+   dup 316 /Icircumflex
+   dup 317 /Idieresis
+   dup 314 /Igrave
+   dup 334 /Udieresis
+   dup 335 /Yacute
+   dup 376 /thorn
+   dup 337 /germandbls
+   dup 341 /aacute
+   dup 342 /acircumflex
+   dup 344 /adieresis
+   dup 346 /ae
+   dup 340 /agrave
+   dup 345 /aring
+   dup 347 /ccedilla
+   dup 351 /eacute
+   dup 352 /ecircumflex
+   dup 353 /edieresis
+   dup 350 /egrave
+   dup 355 /iacute
+   dup 356 /icircumflex
+   dup 357 /idieresis
+   dup 354 /igrave
+   dup 360 /dcroat
+   dup 361 /ntilde
+   dup 363 /oacute
+   dup 364 /ocircumflex
+   dup 366 /odieresis
+   dup 362 /ograve
+   dup 365 /otilde
+   dup 370 /oslash
+   dup 372 /uacute
+   dup 373 /ucircumflex
+   dup 374 /udieresis
+   dup 371 /ugrave
+   dup 375 /yacute
+   dup 377 /ydieresis  
+ 
+ % Set up ISO Latin 1 character encoding
+ /starnetISO {
+         dup dup findfont dup length dict begin
+         { 1 index /FID ne { def }{ pop pop } ifelse
+         } forall
+         /Encoding EncodingVector def
+         currentdict end definefont
+ } def
+ /Times-Roman starnetISO def
+ /Times-Italic starnetISO def
+ /Times-Bold starnetISO def
+ /Times-BoldItalic starnetISO def
+ /Helvetica starnetISO def
+ /Helvetica-Oblique starnetISO def
+ /Helvetica-Bold starnetISO def
+ /Helvetica-BoldOblique starnetISO def
+ /Courier starnetISO def
+ /Courier-Oblique starnetISO def
+ /Courier-Bold starnetISO def
+ /Courier-BoldOblique starnetISO def
+ cleartomark
+ } bind def
+ 
+ %%BeginResource: procset
+ /coord-font-family /Times-Roman def
+ /default-font-family /Times-Roman def
+ /coordfont coord-font-family findfont 8 scalefont def
+ 
+ /InvScaleFactor 1.0 def
+ /set_scale {
+ 	dup 1 exch div /InvScaleFactor exch def
+ 	dup scale
+ } bind def
+ 
+ % styles
+ /solid { [] 0 setdash } bind def
+ /dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+ /dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+ /invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+ /bold { 2 setlinewidth } bind def
+ /filled { } bind def
+ /unfilled { } bind def
+ /rounded { } bind def
+ /diagonals { } bind def
+ 
+ % hooks for setting color 
+ /nodecolor { sethsbcolor } bind def
+ /edgecolor { sethsbcolor } bind def
+ /graphcolor { sethsbcolor } bind def
+ /nopcolor {pop pop pop} bind def
+ 
+ /beginpage {	% i j npages
+ 	/npages exch def
+ 	/j exch def
+ 	/i exch def
+ 	/str 10 string def
+ 	npages 1 gt {
+ 		gsave
+ 			coordfont setfont
+ 			0 0 moveto
+ 			(\() show i str cvs show (,) show j str cvs show (\)) show
+ 		grestore
+ 	} if
+ } bind def
+ 
+ /set_font {
+ 	findfont exch
+ 	scalefont setfont
+ } def
+ 
+ % draw aligned label in bounding box aligned to current point
+ /alignedtext {			% width adj text
+ 	/text exch def
+ 	/adj exch def
+ 	/width exch def
+ 	gsave
+ 		width 0 gt {
+ 			text stringwidth pop adj mul 0 rmoveto
+ 		} if
+ 		[] 0 setdash
+ 		text show
+ 	grestore
+ } def
+ 
+ /boxprim {				% xcorner ycorner xsize ysize
+ 		4 2 roll
+ 		moveto
+ 		2 copy
+ 		exch 0 rlineto
+ 		0 exch rlineto
+ 		pop neg 0 rlineto
+ 		closepath
+ } bind def
+ 
+ /ellipse_path {
+ 	/ry exch def
+ 	/rx exch def
+ 	/y exch def
+ 	/x exch def
+ 	matrix currentmatrix
+ 	newpath
+ 	x y translate
+ 	rx ry scale
+ 	0 0 1 0 360 arc
+ 	setmatrix
+ } bind def
+ 
+ /endpage { showpage } bind def
+ /showpage { } def
+ 
+ /layercolorseq
+ 	[	% layer color sequence - darkest to lightest
+ 		[0 0 0]
+ 		[.2 .8 .8]
+ 		[.4 .8 .8]
+ 		[.6 .8 .8]
+ 		[.8 .8 .8]
+ 	]
+ def
+ 
+ /layerlen layercolorseq length def
+ 
+ /setlayer {/maxlayer exch def /curlayer exch def
+ 	layercolorseq curlayer 1 sub layerlen mod get
+ 	aload pop sethsbcolor
+ 	/nodecolor {nopcolor} def
+ 	/edgecolor {nopcolor} def
+ 	/graphcolor {nopcolor} def
+ } bind def
+ 
+ /onlayer { curlayer ne {invis} if } def
+ 
+ /onlayers {
+ 	/myupper exch def
+ 	/mylower exch def
+ 	curlayer mylower lt
+ 	curlayer myupper gt
+ 	or
+ 	{invis} if
+ } def
+ 
+ /curlayer 0 def
+ 
+ %%EndResource
+ %%EndProlog
+ %%BeginSetup
+ 14 default-font-family set_font
+ 1 setmiterlimit
+ % /arrowlength 10 def
+ % /arrowwidth 5 def
+ 
+ % make sure pdfmark is harmless for PS-interpreters other than Distiller
+ /pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+ % make '<<' and '>>' safe on PS Level 1 devices
+ /languagelevel where {pop languagelevel}{1} ifelse
+ 2 lt {
+     userdict (<<) cvn ([) cvn load put
+     userdict (>>) cvn ([) cvn load put
+ } if
+ 
+ %%EndSetup
+ %%Page: 1 1
+ %%PageBoundingBox: 36 36 675 513
+ %%PageOrientation: Portrait
+ gsave
+ 35 35 640 478 boxprim clip newpath
+ 36 36 translate
+ 0 0 1 beginpage
+ 0 0 translate 0 rotate
+ 0.000 0.000 0.000 graphcolor
+ 14.00 /Times-Roman set_font
+ gsave 10 dict begin
+ 319 5 moveto 133 -0.5 (Dependence Graph) alignedtext
+ end grestore
+ 
+ %	Node0x100ddd6f0
+ gsave 10 dict begin
+ newpath 251 408 moveto
+ 491 408 lineto
+ 491 448 lineto
+ 251 448 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 371 433 moveto 56 -0.5 (add \(n8\)) alignedtext
+ end grestore
+ newpath 251 428 moveto
+ 491 428 lineto
+ stroke
+ gsave 10 dict begin
+ 311 413 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ newpath 371 408 moveto
+ 371 428 lineto
+ stroke
+ gsave 10 dict begin
+ 431 413 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd770
+ gsave 10 dict begin
+ newpath 82 332 moveto
+ 202 332 lineto
+ 202 372 lineto
+ 82 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 142 357 moveto 45 -0.5 (sll \(n9\)) alignedtext
+ end grestore
+ newpath 82 352 moveto
+ 202 352 lineto
+ stroke
+ gsave 10 dict begin
+ 142 337 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd6f0 -> Node0x100ddd770
+ newpath 285 408 moveto
+ 263 400 230 387 201 375 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 203 373 moveto
+ 193 372 lineto
+ 201 378 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd970
+ gsave 10 dict begin
+ newpath 517 332 moveto
+ 637 332 lineto
+ 637 372 lineto
+ 517 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 577 357 moveto 50 -0.5 (sll \(n17\)) alignedtext
+ end grestore
+ newpath 517 352 moveto
+ 637 352 lineto
+ stroke
+ gsave 10 dict begin
+ 577 337 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd6f0 -> Node0x100ddd970
+ newpath 453 408 moveto
+ 472 400 500 387 525 376 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 525 379 moveto
+ 533 372 lineto
+ 523 374 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd870
+ gsave 10 dict begin
+ newpath 0 256 moveto
+ 230 256 lineto
+ 230 296 lineto
+ 0 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 115 281 moveto 44 -0.5 (st \(n11\)) alignedtext
+ end grestore
+ newpath 0 276 moveto
+ 230 276 lineto
+ stroke
+ gsave 10 dict begin
+ 57 261 moveto 101 -0.5 (Anti\(IteDiff: 1\)) alignedtext
+ end grestore
+ newpath 115 256 moveto
+ 115 276 lineto
+ stroke
+ gsave 10 dict begin
+ 172 261 moveto 101 -0.5 (Anti\(IteDiff: 1\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd770 -> Node0x100ddd870
+ newpath 138 332 moveto
+ 135 325 131 315 127 306 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 129 304 moveto
+ 123 296 lineto
+ 124 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddda70
+ gsave 10 dict begin
+ newpath 524 256 moveto
+ 639 256 lineto
+ 639 296 lineto
+ 524 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 581 281 moveto 51 -0.5 (st \(n22\)) alignedtext
+ end grestore
+ newpath 524 276 moveto
+ 639 276 lineto
+ stroke
+ gsave 10 dict begin
+ 581 261 moveto 101 -0.5 (Anti\(IteDiff: 1\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd970 -> Node0x100ddda70
+ newpath 578 332 moveto
+ 579 325 579 315 579 305 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 581 306 moveto
+ 580 296 lineto
+ 576 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd4f0
+ gsave 10 dict begin
+ newpath 252 332 moveto
+ 492 332 lineto
+ 492 372 lineto
+ 252 372 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 372 357 moveto 56 -0.5 (add \(n3\)) alignedtext
+ end grestore
+ newpath 252 352 moveto
+ 492 352 lineto
+ stroke
+ gsave 10 dict begin
+ 312 337 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ newpath 372 332 moveto
+ 372 352 lineto
+ stroke
+ gsave 10 dict begin
+ 432 337 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd570
+ gsave 10 dict begin
+ newpath 248 256 moveto
+ 368 256 lineto
+ 368 296 lineto
+ 248 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 308 281 moveto 46 -0.5 (sll \(n4\)) alignedtext
+ end grestore
+ newpath 248 276 moveto
+ 368 276 lineto
+ stroke
+ gsave 10 dict begin
+ 308 261 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd4f0 -> Node0x100ddd570
+ newpath 311 332 moveto
+ 310 325 310 315 310 305 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 313 306 moveto
+ 309 296 lineto
+ 308 306 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd5f0
+ gsave 10 dict begin
+ newpath 386 256 moveto
+ 506 256 lineto
+ 506 296 lineto
+ 386 296 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 446 281 moveto 45 -0.5 (sll \(n5\)) alignedtext
+ end grestore
+ newpath 386 276 moveto
+ 506 276 lineto
+ stroke
+ gsave 10 dict begin
+ 446 261 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd4f0 -> Node0x100ddd5f0
+ newpath 434 332 moveto
+ 436 325 438 315 440 305 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 442 306 moveto
+ 442 296 lineto
+ 437 305 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd8f0
+ gsave 10 dict begin
+ newpath 295 180 moveto
+ 535 180 lineto
+ 535 220 lineto
+ 295 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 415 205 moveto 49 -0.5 (ld \(n12\)) alignedtext
+ end grestore
+ newpath 295 200 moveto
+ 535 200 lineto
+ stroke
+ gsave 10 dict begin
+ 355 185 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ newpath 415 180 moveto
+ 415 200 lineto
+ stroke
+ gsave 10 dict begin
+ 475 185 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd570 -> Node0x100ddd8f0
+ newpath 324 256 moveto
+ 337 248 357 236 375 225 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 376 227 moveto
+ 383 220 lineto
+ 373 223 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd670
+ gsave 10 dict begin
+ newpath 140 180 moveto
+ 260 180 lineto
+ 260 220 lineto
+ 140 220 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 200 205 moveto 44 -0.5 (ld \(n7\)) alignedtext
+ end grestore
+ newpath 140 200 moveto
+ 260 200 lineto
+ stroke
+ gsave 10 dict begin
+ 200 185 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd5f0 -> Node0x100ddd670
+ newpath 402 256 moveto
+ 366 248 315 236 269 222 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 270 220 moveto
+ 260 220 lineto
+ 269 225 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd870 -> Node0x100ddd670
+ newpath 80 256 moveto
+ 98 248 125 235 148 224 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 149 226 moveto
+ 157 220 lineto
+ 147 222 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd870 -> Node0x100ddd670
+ newpath 176 256 moveto
+ 179 249 183 239 187 230 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 190 230 moveto
+ 191 220 lineto
+ 185 228 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd7f0
+ gsave 10 dict begin
+ newpath 105 104 moveto
+ 225 104 lineto
+ 225 144 lineto
+ 105 144 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 165 129 moveto 77 -0.5 (fmuls \(n10\)) alignedtext
+ end grestore
+ newpath 105 124 moveto
+ 225 124 lineto
+ stroke
+ gsave 10 dict begin
+ 165 109 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd670 -> Node0x100ddd7f0
+ newpath 195 180 moveto
+ 191 173 185 162 180 152 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 183 152 moveto
+ 176 144 lineto
+ 178 154 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd7f0 -> Node0x100ddd870
+ newpath 83 247 moveto
+ 96 194 136 145 155 124 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 81 246 moveto
+ 81 256 lineto
+ 86 247 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd470
+ gsave 10 dict begin
+ newpath 266 104 moveto
+ 504 104 lineto
+ 504 144 lineto
+ 266 144 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 385 129 moveto 141 -0.5 (Pred Node \(no_exit\)) alignedtext
+ end grestore
+ newpath 266 124 moveto
+ 504 124 lineto
+ stroke
+ gsave 10 dict begin
+ 325 109 moveto 105 -0.5 (Pred\(IteDiff: 0\)) alignedtext
+ end grestore
+ newpath 385 104 moveto
+ 385 124 lineto
+ stroke
+ gsave 10 dict begin
+ 444 109 moveto 105 -0.5 (Pred\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd8f0 -> Node0x100ddd470
+ newpath 360 180 moveto
+ 363 173 368 163 372 153 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 374 154 moveto
+ 376 144 lineto
+ 370 152 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd9f0
+ gsave 10 dict begin
+ newpath 472 28 moveto
+ 592 28 lineto
+ 592 68 lineto
+ 472 68 lineto
+ closepath
+ stroke
+ gsave 10 dict begin
+ 532 53 moveto 77 -0.5 (fmuls \(n19\)) alignedtext
+ end grestore
+ newpath 472 48 moveto
+ 592 48 lineto
+ stroke
+ gsave 10 dict begin
+ 532 33 moveto 106 -0.5 (True\(IteDiff: 0\)) alignedtext
+ end grestore
+ end grestore
+ 
+ %	Node0x100ddd8f0 -> Node0x100ddd9f0
+ newpath 486 180 moveto
+ 494 171 506 157 513 144 curveto
+ 523 122 528 96 530 76 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 532 78 moveto
+ 531 68 lineto
+ 527 78 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd470 -> Node0x100ddd9f0
+ newpath 358 104 moveto
+ 385 96 426 82 463 71 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 463 74 moveto
+ 472 68 lineto
+ 462 69 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd470 -> Node0x100ddda70
+ newpath 575 248 moveto
+ 570 227 560 199 544 180 curveto
+ 523 154 489 135 467 124 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 572 247 moveto
+ 577 256 lineto
+ 577 246 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddd9f0 -> Node0x100ddda70
+ newpath 578 248 moveto
+ 576 228 572 203 568 180 curveto
+ 558 130 542 71 535 48 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 575 246 moveto
+ 579 256 lineto
+ 580 246 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ 
+ %	Node0x100ddda70 -> Node0x100ddd8f0
+ newpath 556 256 moveto
+ 534 248 502 235 474 224 curveto
+ stroke
+ gsave 10 dict begin
+ solid
+ 0.000 0.000 0.000 edgecolor
+ newpath 475 222 moveto
+ 465 220 lineto
+ 473 226 lineto
+ closepath
+ fill
+ 0.000 0.000 0.000 edgecolor
+ end grestore
+ endpage
+ grestore
+ %%PageTrailer
+ %%EndPage: 1
+ %%Trailer
+ %%Pages: 1
+ end
+ restore
+ %%EOF
+ 
+ %%EndDocument
+ 
+  endTexFig
+  1563 6283 a Fx(Figure)60 b(5.5:)79 b(Dep)5 b(endence)60
+ b(Graph)g(After)h(Dep)5 b(endence)59 b(Analysis)p 1199
+ 7274 5352 7 v 1196 7457 7 183 v 1298 7402 a Fs(No)t(de)p
+ 2703 7457 V 2736 7457 V 1192 w(ASAP)p 3355 7457 V 199
+ w(ALAP)p 3985 7457 V 199 w(MOB)p 4554 7457 V 200 w(Depth)p
+ 5169 7457 V 200 w(Heigh)l(t)p 5812 7457 V 199 w(Latency)p
+ 6547 7457 V 1199 7464 5352 7 v 1196 7646 7 183 v 1298
+ 7591 a(PredNo)t(de)53 b(\(no)p 2249 7591 47 7 v 55 w(exit\))p
+ 2703 7646 7 183 v 2736 7646 V 575 w(5)p 3355 7646 V 553
+ w(5)p 3985 7646 V 492 w(0)p 4554 7646 V 538 w(5)p 5169
+ 7646 V 566 w(7)p 5812 7646 V 658 w(3)p 6547 7646 V 1196
+ 7829 V 1298 7774 a(add)f(\(n3\))p 2703 7829 V 2736 7829
+ V 1303 w(0)p 3355 7829 V 553 w(0)p 3985 7829 V 492 w(0)p
+ 4554 7829 V 538 w(0)p 5169 7829 V 489 w(12)p 5812 7829
+ V 658 w(1)p 6547 7829 V 1196 8012 V 1298 7957 a(sll)f(\(n4\))p
+ 2703 8012 V 2736 8012 V 1404 w(1)p 3355 8012 V 553 w(1)p
+ 3985 8012 V 492 w(0)p 4554 8012 V 538 w(1)p 5169 8012
+ V 489 w(11)p 5812 8012 V 658 w(1)p 6547 8012 V 1196 8194
+ V 1298 8139 a(sll)g(\(n5\))p 2703 8194 V 2736 8194 V
+ 1404 w(1)p 3355 8194 V 553 w(4)p 3985 8194 V 492 w(3)p
+ 4554 8194 V 538 w(1)p 5169 8194 V 566 w(8)p 5812 8194
+ V 658 w(1)p 6547 8194 V 1196 8377 V 1298 8322 a(ld)h(\(n7\))p
+ 2703 8377 V 2736 8377 V 1422 w(2)p 3355 8377 V 553 w(5)p
+ 3985 8377 V 492 w(3)p 4554 8377 V 538 w(2)p 5169 8377
+ V 566 w(7)p 5812 8377 V 658 w(3)p 6547 8377 V 1196 8560
+ V 1298 8505 a(add)g(\(n8\))p 2703 8560 V 2736 8560 V
+ 1303 w(0)p 3355 8560 V 477 w(10)p 3985 8560 V 414 w(10)p
+ 4554 8560 V 538 w(0)p 5169 8560 V 566 w(2)p 5812 8560
+ V 658 w(1)p 6547 8560 V 1196 8742 V 1298 8687 a(sll)f(\(n9\))p
+ 2703 8742 V 2736 8742 V 1404 w(1)p 3355 8742 V 477 w(11)p
+ 3985 8742 V 414 w(10)p 4554 8742 V 538 w(1)p 5169 8742
+ V 566 w(1)p 5812 8742 V 658 w(1)p 6547 8742 V 1196 8925
+ V 1298 8870 a(fm)l(uls)g(\(n10\))p 2703 8925 V 2736 8925
+ V 1114 w(5)p 3355 8925 V 553 w(8)p 3985 8925 V 492 w(3)p
+ 4554 8925 V 538 w(5)p 5169 8925 V 566 w(4)p 5812 8925
+ V 658 w(4)p 6547 8925 V 1196 9107 V 1298 9053 a(st)g(\(n11\))p
+ 2703 9107 V 2736 9107 V 1353 w(9)p 3355 9107 V 477 w(12)p
+ 3985 9107 V 491 w(3)p 4554 9107 V 538 w(9)p 5169 9107
+ V 566 w(0)p 5812 9107 V 658 w(1)p 6547 9107 V 1196 9290
+ V 1298 9235 a(ld)h(\(n12\))p 2703 9290 V 2736 9290 V
+ 1345 w(2)p 3355 9290 V 553 w(2)p 3985 9290 V 492 w(0)p
+ 4554 9290 V 538 w(2)p 5169 9290 V 489 w(10)p 5812 9290
+ V 658 w(3)p 6547 9290 V 1196 9473 V 1298 9418 a(sll)f(\(n17\))p
+ 2703 9473 V 2736 9473 V 1327 w(1)p 3355 9473 V 477 w(11)p
+ 3985 9473 V 414 w(10)p 4554 9473 V 538 w(1)p 5169 9473
+ V 566 w(1)p 5812 9473 V 658 w(1)p 6547 9473 V 1196 9655
+ V 1298 9601 a(fm)l(uls)g(\(n19\))p 2703 9655 V 2736 9655
+ V 1114 w(8)p 3355 9655 V 553 w(8)p 3985 9655 V 492 w(0)p
+ 4554 9655 V 538 w(8)p 5169 9655 V 566 w(4)p 5812 9655
+ V 658 w(4)p 6547 9655 V 1196 9838 V 1298 9783 a(st)g(\(n22\))p
+ 2703 9838 V 2736 9838 V 1276 w(12)p 3355 9838 V 477 w(12)p
+ 3985 9838 V 491 w(0)p 4554 9838 V 461 w(12)p 5169 9838
+ V 566 w(0)p 5812 9838 V 658 w(1)p 6547 9838 V 1199 9845
+ 5352 7 v 1775 10237 a Fx(T)-15 b(able)60 b(5.2:)80 b(No)5
+ b(de)61 b(A)-5 b(ttributes)59 b(for)h(Simple)f(Lo)5 b(op)60
+ b(Example)3809 11136 y(57)p eop end
+ %%Page: 58 65
+ TeXDict begin 58 64 bop 282 183 a Fx(Our)60 b(extended)e(Swing)h(Mo)5
+ b(dulo)58 b(Sc)-5 b(heduling)58 b(algorithm)f(p)5 b(erforms)58
+ b(no)5 b(de)59 b(ordering)g(exactly)f(as)g(the)h(orig-)0
+ 548 y(inal)66 b(algorithm.)97 b(Using)66 b(the)g(no)5
+ b(de)67 b(attributes)e(and)h(the)h(DDG,)e(it)h(determines)f(the)h(b)5
+ b(est)66 b(ordering)h(p)5 b(ossible)0 913 y(in)60 b(order)h(to)f(ac)-5
+ b(hiev)g(e)59 b(the)i(most)e(optimal)g(sc)-5 b(hedule.)79
+ b(It)60 b(b)5 b(egins)59 b(b)-5 b(y)61 b(determining)d(the)i(partial)g
+ (order)h(whic)-5 b(h)60 b(is)0 1279 y(a)g(list)f(of)h(sets)g(of)f(no)5
+ b(des.)80 b(Figure)60 b(5.6)g(sho)-5 b(ws)60 b(the)g(partial)f(order)h
+ (for)h(our)f(example.)79 b(Recall)59 b(from)g(Section)h(4.5)0
+ 1644 y(that)53 b(the)h(partial)e(order)i(lists)f(the)g(recurrences)g
+ (from)g(the)h(highest)f(RecMI)5 b(I)52 b(to)h(the)h(lo)-5
+ b(w)g(est,)54 b(with)f(the)g(remain-)0 2010 y(ing)k(sets)f(consisting)f
+ (of)i(the)g(other)g(connected)f(comp)5 b(onen)-5 b(ts)56
+ b(of)h(the)f(graph.)80 b(Since)56 b(w)-5 b(e)58 b(ha)-5
+ b(v)g(e)56 b(t)-5 b(w)g(o)58 b(recurrences)0 2375 y(with)71
+ b(the)f(same)g(RecMI)5 b(I,)69 b(those)i(t)-5 b(w)g(o)71
+ b(o)5 b(ccur)71 b(\014rst)f(in)h(the)g(partial)e(order)j(\(Set)e(#1)h
+ (and)g(Set)f(#2\).)111 b(Sets)71 b(#3)0 2740 y(and)63
+ b(#4)g(represen)-5 b(t)63 b(the)g(remaining)f(t)-5 b(w)g(o)63
+ b(connected)g(comp)5 b(onen)-5 b(ts)61 b(of)i(the)g(DDG)g(once)g(the)g
+ (t)-5 b(w)g(o)64 b(recurrences)0 3106 y(are)d(remo)-5
+ b(v)g(ed.)0 3397 y Fd(Set)69 b(#1:)h(PredNode)d(\(no_exit\),)f(ld)k
+ (\(n12\),)e(fmuls)g(\(n19\),)g(st)i(\(n22\))0 3555 y(Set)f(#2:)h(ld)f
+ (\(n7\),)g(fmuls)f(\(n10\),)g(st)i(\(n11\))0 3713 y(Set)f(#3:)h(add)f
+ (\(n3\),)f(sll)i(\(n4\),)e(sll)h(\(n5\))0 3870 y(Set)g(#4:)h(add)f
+ (\(n8\),)f(sll)i(\(n9\),)e(sll)h(\(n17\))1818 4461 y
+ Fx(Figure)60 b(5.6:)79 b(Sup)5 b(erblo)g(c)-5 b(k)60
+ b(Lo)5 b(op)60 b(Example)f(P)-5 b(artial)59 b(Order)282
+ 5061 y(Using)72 b(this)g(partial)f(order,)k(the)d(next)h(phase)f(of)g
+ (our)g(extended)g(SMS)g(algorithm)f(\(lik)-5 b(e)71 b(the)h(original\))
+ f(is)0 5427 y(to)64 b(determine)e(the)i(\014nal)f(no)5
+ b(de)64 b(ordering.)90 b(The)64 b(\014nal)g(no)5 b(de)64
+ b(ordering)f(algorithm)g(\(describ)5 b(ed)62 b(in)i(Figure)f(4.9\))0
+ 5792 y(tra)-5 b(v)g(erses)69 b(eac)-5 b(h)69 b(subgraph)g(that)g(eac)-5
+ b(h)69 b(set)g(represen)-5 b(ts)69 b(in)g(the)g(partial)f(order.)108
+ b(It)69 b(b)5 b(egins)69 b(with)g(Set)g(#1)g(and)0 6158
+ y(determines)50 b(that)h(the)g(st)h(\(n22\))f(is)g(the)g(most)g
+ (critical)e(no)5 b(de)52 b(and)g(places)e(it)h(\014rst)h(on)f(the)h
+ (\014nal)f(order)h(list.)76 b(Eac)-5 b(h)0 6523 y(ancestor)56
+ b(to)g(the)h(st)f(\(n22\))g(is)g(visited)f(according)h(to)g(their)g
+ (depth)g(and)h(added)g(to)f(the)g(\014nal)h(no)5 b(de)56
+ b(order.)79 b(This)0 6888 y(means)68 b(that)h(fm)-5 b(uls)68
+ b(\(n19\))h(with)g(a)g(depth)g(of)g(8)h(\(greatest)e(depth)h(out)g(of)g
+ (Set)g(#1\))g(is)f(added)i(\014rst,)h(follo)-5 b(w)g(ed)0
+ 7254 y(b)g(y)70 b(PredNo)5 b(de,)73 b(and)d(\014nally)f(the)h(ld)g
+ (\(n12\).)109 b(This)70 b(pro)5 b(cess)69 b(is)h(rep)5
+ b(eated)69 b(for)i(eac)-5 b(h)69 b(set)h(in)g(the)g(partial)f(order)0
+ 7619 y(\(tra)-5 b(v)g(ersing)71 b(b)5 b(ottom-up)71 b(or)i(top-do)-5
+ b(wn\))72 b(un)-5 b(til)71 b(all)g(no)5 b(des)72 b(ha)-5
+ b(v)g(e)73 b(b)5 b(een)72 b(added)g(to)g(the)g(\014nal)g(order.)117
+ b(The)73 b(list)0 7984 y(b)5 b(elo)-5 b(w)60 b(is)g(the)g(\014nal)g(no)
+ 5 b(de)61 b(ordering)f(for)g(our)h(example:)282 8350
+ y Fq(O)80 b Fx(=)c Fr(f)g Fx(st)f(\(n22\),)j(fm)-5 b(uls)74
+ b(\(n19\),)k(PredNo)5 b(de)75 b(\(no)p 3852 8350 55 7
+ v 65 w(exit\),)j(ld)d(\(n12\),)j(st\(n11\),)f(fm)-5 b(uls)74
+ b(\(n10\),)k(ld)d(\(n7\),)j(sll)0 8715 y(\(n4\),)59 b(sll)h(\(n5\),)f
+ (add)i(\(n3\),)e(sll)h(\(n9\),)f(sll)g(\(n17\),)h(add)g(\(n8\))g
+ Fr(g)282 9081 y Fx(Using)i(the)f(\014nal)h(no)5 b(de)62
+ b(ordering,)f(eac)-5 b(h)62 b(instruction)e(is)h(placed)g(in)h(the)g
+ (\014nal)f(sc)-5 b(hedule.)84 b(T)-15 b(able)61 b(5.3)g(sho)-5
+ b(ws)0 9446 y(the)48 b(sc)-5 b(hedule)48 b(for)g(a)h(single)e
+ (iteration)g(of)h(our)h(sup)5 b(erblo)g(c)-5 b(k)47 b(lo)5
+ b(op)48 b(example.)75 b(The)49 b(SP)-15 b(AR)-5 b(C)49
+ b(I)5 b(I)g(Ii)47 b(arc)-5 b(hitecture)47 b(can)0 9811
+ y(issue)53 b(4)h(instructions)f(p)5 b(er)54 b(cycle.)77
+ b(The)55 b(com)-5 b(bination)52 b(of)i(instructions)e(that)i(can)g(b)5
+ b(e)54 b(issued)f(dep)5 b(ends)54 b(on)g(what)0 10177
+ y(resources)48 b(eac)-5 b(h)49 b(instruction)f(uses)g(during)h(eac)-5
+ b(h)49 b(stage)f(of)h(the)f(pip)5 b(eline.)75 b(This)49
+ b(information)e(is)h(acquired)h(using)0 10542 y(the)68
+ b(Sc)-5 b(hedInfo)68 b(API)g(discussed)f(in)h(Section)g(4.1.1.)103
+ b(F)-15 b(or)68 b(simplicit)-5 b(y)65 b(the)k(sc)-5 b(hedule)67
+ b(sho)-5 b(w)68 b(in)h(T)-15 b(able)68 b(5.3)g(only)3809
+ 11136 y(58)p eop end
+ %%Page: 59 66
+ TeXDict begin 59 65 bop 1780 7 4190 7 v 1777 189 7 183
+ v 1879 134 a Fs(Cycle)p 2347 189 V 2380 189 V 544 w(Issue1)p
+ 3297 189 V 1049 w(Issue2)p 4753 189 V 199 w(Issue3)p
+ 5359 189 V 199 w(Issue4)p 5966 189 V 1780 196 4190 7
+ v 1777 379 7 183 v 1879 324 a(0)p 2347 379 V 2380 379
+ V 716 w(add\(n3\))p 3297 379 V 4753 379 V 5359 379 V
+ 5966 379 V 1780 385 4190 7 v 1777 568 7 183 v 1879 513
+ a(1)p 2347 568 V 2380 568 V 817 w(sll\(n5\))p 3297 568
+ V 4753 568 V 5359 568 V 5966 568 V 1780 575 4190 7 v
+ 1777 757 7 183 v 1879 702 a(2)p 2347 757 V 2380 757 V
+ 835 w(ld\(n7\))p 3297 757 V 4753 757 V 5359 757 V 5966
+ 757 V 1780 764 4190 7 v 1777 946 7 183 v 1879 892 a(3)p
+ 2347 946 V 2380 946 V 3297 946 V 4753 946 V 5359 946
+ V 5966 946 V 1780 953 4190 7 v 1777 1136 7 183 v 1879
+ 1081 a(4)p 2347 1136 V 2380 1136 V 817 w(sll\(n4\))p
+ 3297 1136 V 4753 1136 V 5359 1136 V 5966 1136 V 1780
+ 1142 4190 7 v 1777 1325 7 183 v 1879 1270 a(5)p 2347
+ 1325 V 2380 1325 V 758 w(ld\(n12\))p 3297 1325 V 4753
+ 1325 V 5359 1325 V 5966 1325 V 1780 1332 4190 7 v 1777
+ 1514 7 183 v 1879 1460 a(6)p 2347 1514 V 2380 1514 V
+ 3297 1514 V 4753 1514 V 5359 1514 V 5966 1514 V 1780
+ 1521 4190 7 v 1777 1704 7 183 v 1879 1649 a(7)p 2347
+ 1704 V 2380 1704 V 3297 1704 V 4753 1704 V 5359 1704
+ V 5966 1704 V 1780 1710 4190 7 v 1777 1893 7 183 v 1879
+ 1838 a(8)p 2347 1893 V 2380 1893 V 527 w(fm)l(uls\(n10\))p
+ 3297 1893 V 198 w(PredNo)t(de\(no)p 4298 1838 47 7 v
+ 56 w(exit\))p 4753 1893 7 183 v 5359 1893 V 5966 1893
+ V 1780 1900 4190 7 v 1777 2082 7 183 v 1879 2027 a(9)p
+ 2347 2082 V 2380 2082 V 3297 2082 V 4753 2082 V 5359
+ 2082 V 5966 2082 V 1780 2089 4190 7 v 1777 2271 7 183
+ v 1879 2217 a(10)p 2347 2271 V 2380 2271 V 639 w(add\(n8\))p
+ 3297 2271 V 4753 2271 V 5359 2271 V 5966 2271 V 1780
+ 2278 4190 7 v 1780 2311 V 1777 2494 7 183 v 1879 2439
+ a(11)p 2347 2494 V 2380 2494 V 740 w(sll\(n9\))p 3297
+ 2494 V 737 w(fm)l(uls\(n19\))p 4753 2494 V 5359 2494
+ V 5966 2494 V 1780 2501 4190 7 v 1777 2683 7 183 v 1879
+ 2628 a(12)p 2347 2683 V 2380 2683 V 689 w(st\(n11\))p
+ 3297 2683 V 4753 2683 V 5359 2683 V 5966 2683 V 1780
+ 2690 4190 7 v 1777 2873 7 183 v 1879 2818 a(13)p 2347
+ 2873 V 2380 2873 V 3297 2873 V 4753 2873 V 5359 2873
+ V 5966 2873 V 1780 2879 4190 7 v 1777 3062 7 183 v 1879
+ 3007 a(14)p 2347 3062 V 2380 3062 V 663 w(sll\(n17\))p
+ 3297 3062 V 4753 3062 V 5359 3062 V 5966 3062 V 1780
+ 3068 4190 7 v 1777 3251 7 183 v 1879 3196 a(15)p 2347
+ 3251 V 2380 3251 V 689 w(st\(n22\))p 3297 3251 V 4753
+ 3251 V 5359 3251 V 5966 3251 V 1780 3258 4190 7 v 1394
+ 3650 a Fx(T)-15 b(able)60 b(5.3:)80 b(Sc)-5 b(hedule)60
+ b(for)g(a)g(Single)g(Iteration)f(of)h(the)g(Lo)5 b(op)60
+ b(Example)0 4200 y(sho)-5 b(ws)58 b(the)f(issue)g(slots,)f(but)i(the)f
+ (sc)-5 b(heduling)56 b(algorithm)g(c)-5 b(hec)g(ks)57
+ b(that)g(b)5 b(oth)58 b(an)g(issue)e(slot)h(and)h(all)f(resources)0
+ 4565 y(are)k(a)-5 b(v)-10 b(ailable.)282 4930 y(Our)62
+ b(ac)-5 b(hiev)g(ed)60 b(I)5 b(I)60 b(v)-10 b(alue)60
+ b(for)h(this)f(example)f(w)-5 b(as)61 b(10)g(cycles,)e(whic)-5
+ b(h)61 b(is)f(greater)g(than)h(our)g(calculated)e(MI)5
+ b(I)0 5296 y(\(8)60 b(cycles\).)80 b(This)60 b(means)g(that)g(all)g
+ (instructions)e(from)i(cycle)g(0)g(to)h(cycle)f(10)g(are)h(from)f(the)g
+ (curren)-5 b(t)61 b(iteration)0 5661 y(in)70 b(the)g(k)-5
+ b(ernel,)71 b(and)f(all)f(instructions)g(sc)-5 b(heduled)68
+ b(after)i(cycle)f(10)h(b)5 b(elong)70 b(to)f(another)h(stage)g(in)f
+ (the)h(k)-5 b(ernel.)0 6027 y(T)-15 b(able)60 b(5.4)g(sho)-5
+ b(ws)60 b(the)g(k)-5 b(ernel)60 b(for)g(our)h(Mo)5 b(dulo)60
+ b(Sc)-5 b(heduled)59 b(lo)5 b(op.)p 1543 6268 4662 7
+ v 1540 6451 7 183 v 1643 6396 a Fs(Cycle)p 2111 6451
+ V 2144 6451 V 543 w(Issue1)p 3061 6451 V 1049 w(Issue2)p
+ 4517 6451 V 672 w(Issue3)p 5596 6451 V 200 w(Issue4)p
+ 6202 6451 V 1543 6457 4662 7 v 1540 6640 7 183 v 1643
+ 6585 a(0)p 2111 6640 V 2144 6640 V 715 w(add\(n3\))p
+ 3061 6640 V 867 w(sll\(n9\)[1])p 4517 6640 V 197 w(fm)l(uls\(n19\)[1])p
+ 5596 6640 V 6202 6640 V 1543 6646 4662 7 v 1540 6829
+ 7 183 v 1643 6774 a(1)p 2111 6829 V 2144 6829 V 817 w(sll\(n5\))p
+ 3061 6829 V 814 w(st\(n11[1]\))p 4517 6829 V 5596 6829
+ V 6202 6829 V 1543 6836 4662 7 v 1540 7018 7 183 v 1643
+ 6964 a(2)p 2111 7018 V 2144 7018 V 835 w(ld\(n7\))p 3061
+ 7018 V 4517 7018 V 5596 7018 V 6202 7018 V 1543 7025
+ 4662 7 v 1540 7208 7 183 v 1643 7153 a(3)p 2111 7208
+ V 2144 7208 V 578 w(sll\(n17\)[1])p 3061 7208 V 4517
+ 7208 V 5596 7208 V 6202 7208 V 1543 7214 4662 7 v 1540
+ 7397 7 183 v 1643 7342 a(4)p 2111 7397 V 2144 7397 V
+ 817 w(sll\(n4\))p 3061 7397 V 814 w(st\(n22\)[1])p 4517
+ 7397 V 5596 7397 V 6202 7397 V 1543 7404 4662 7 v 1540
+ 7586 7 183 v 1643 7531 a(5)p 2111 7586 V 2144 7586 V
+ 758 w(ld\(n12\))p 3061 7586 V 4517 7586 V 5596 7586 V
+ 6202 7586 V 1543 7593 4662 7 v 1540 7776 7 183 v 1643
+ 7721 a(6)p 2111 7776 V 2144 7776 V 3061 7776 V 4517 7776
+ V 5596 7776 V 6202 7776 V 1543 7782 4662 7 v 1540 7965
+ 7 183 v 1643 7910 a(7)p 2111 7965 V 2144 7965 V 3061
+ 7965 V 4517 7965 V 5596 7965 V 6202 7965 V 1543 7971
+ 4662 7 v 1540 8154 7 183 v 1643 8099 a(8)p 2111 8154
+ V 2144 8154 V 527 w(fm)l(uls\(n10\))p 3061 8154 V 198
+ w(PredNo)t(de\(no)p 4062 8099 47 7 v 56 w(exit\))p 4517
+ 8154 7 183 v 5596 8154 V 6202 8154 V 1543 8161 4662 7
+ v 1540 8343 7 183 v 1643 8289 a(9)p 2111 8343 V 2144
+ 8343 V 3061 8343 V 4517 8343 V 5596 8343 V 6202 8343
+ V 1543 8350 4662 7 v 1540 8533 7 183 v 1643 8478 a(10)p
+ 2111 8533 V 2144 8533 V 638 w(add\(n8\))p 3061 8533 V
+ 4517 8533 V 5596 8533 V 6202 8533 V 1543 8539 4662 7
+ v 2458 8931 a Fx(T)-15 b(able)60 b(5.4:)79 b(Kernel)61
+ b(for)f(Lo)5 b(op)60 b(Example)282 9496 y(Because)49
+ b(w)-5 b(e)50 b(ha)-5 b(v)g(e)49 b(instructions)e(in)i(the)h(k)-5
+ b(ernel)48 b(that)h(are)h(from)f(a)g(stage)g(greater)g(than)h(zero)f
+ (\(whic)-5 b(h)49 b(means)0 9861 y(that)55 b(they)g(complete)e(a)j
+ (previous)e(iteration\),)g(w)-5 b(e)56 b(will)e(ha)-5
+ b(v)g(e)55 b(a)g(prologue)g(and)g(an)h(epilogue.)77 b(This)55
+ b(is)f(iden)-5 b(tical)0 10227 y(to)69 b(the)f(original)g(Swing)h(Mo)5
+ b(dulo)68 b(Sc)-5 b(heduling)68 b(algorithm,)h(ho)-5
+ b(w)g(ev)g(er)68 b(w)-5 b(e)70 b(m)-5 b(ust)68 b(handle)g(side)g(exits)
+ g(prop)5 b(erly)-15 b(.)0 10592 y(The)77 b(new)f(reconstructed)g
+ (algorithm)e(describ)5 b(ed)76 b(in)g(Figure)f(5.2)h(transforms)f(our)i
+ (sup)5 b(erblo)g(c)-5 b(k)76 b(lo)5 b(op)75 b(in)-5 b(to)76
+ b(a)3809 11136 y(59)p eop end
+ %%Page: 60 67
+ TeXDict begin 60 66 bop 0 183 a Fx(prologue,)60 b(k)-5
+ b(ernel,)59 b(epilogue,)g(side)h(exit,)f(and)i(side)f(epilogue.)79
+ b(Figure)60 b(5.7,)g(Figure)g(5.8)g(and)h(Figure)f(5.9)g(sho)-5
+ b(w)0 548 y(the)62 b(\014nal)g(LL)-20 b(VM)62 b(mac)-5
+ b(hine)61 b(co)5 b(de)63 b(after)e(the)i(reconstruction.)85
+ b(The)62 b(k)-5 b(ey)63 b(di\013erence)e(to)i(note)f(is)g(that)g(the)g
+ (side)0 913 y(exit)56 b(in)g(the)h(prologue)f(and)h(k)-5
+ b(ernel)56 b(b)5 b(oth)57 b(branc)-5 b(h)56 b(to)h(a)g(side)f(epilogue)
+ f(\(to)h(complete)f(the)i(iterations)e(in)h(\015igh)-5
+ b(t\))0 1279 y(and)70 b(than)h(to)f(a)g(side)g(exit)f(\(to)h(execute)g
+ (an)-5 b(y)70 b(instructions)e(mo)-5 b(v)g(ed)70 b(b)5
+ b(elo)-5 b(w)70 b(the)g(conditional)e(branc)-5 b(h\))71
+ b(b)5 b(efore)0 1644 y(exiting)59 b(the)h(lo)5 b(op.)3809
+ 11136 y(60)p eop end
+ %%Page: 61 68
+ TeXDict begin 61 67 bop -16 2337 a Fo(P)-16 b(R)g(O)g(L)g(O)g(G)g(U)g
+ (E)7 b(:)-1 2495 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g
+ (0)109 b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(:)28 b(P)5 b(h)g(i)g(C)g(p)19
+ b(\))26 b(,)74 b(\045)20 b(g)7 b(0)26 b(,)72 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g(0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)32
+ b(\))-1 2653 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)35 b(\))g(,)83 b(1)35
+ b(,)83 b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))-1 2810 y Fi(a)o(d)o(d)48
+ b Fo(\045)8 b(g)f(0)26 b(,)73 b(\045)28 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)114 b(i)16 b(n)g(d)g(v)g(a)g(r)30 b(\))d(,)73 b(\045)30
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100 b(t)q(m)q(p)21
+ b(.)g(1)g(0)g(\))25 2968 y Fi(s)k(l)g(l)75 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100 b(t)q(m)q(p)19
+ b(.)g(1)g(0)g(\))39 b(,)86 b(2)38 b(,)86 b(\045)35 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(9)g
+ (a)g(0)g(2)g(0)22 b(\))25 3126 y Fi(s)j(l)g(l)75 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100 b(t)q(m)q(p)19
+ b(.)g(1)g(0)g(\))39 b(,)86 b(2)38 b(,)86 b(\045)35 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g
+ (7)g(5)g(c)g(0)23 b(\))19 3284 y Fi(s)c(r)g(l)71 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101 b(m)6 b(a)g(s)g(k)g(H)g(i)25
+ b(\))35 b(,)83 b(0)35 b(,)83 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g
+ (0)121 b(i)48 b(.)25 b(0)g(.)g(0)f(\))11 3441 y Fi(l)11
+ b(d)63 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)31 b(x)14 b(1)g(0)g(0)g(c)g(5)g(4)g(7)g(e)g(0)83
+ b(T)-12 b(M)g(P)g(2)q(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(c)g
+ (0)21 b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g(0)98
+ b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))-1 3599 y Fi(a)o(d)o(d)48
+ b Fo(\045)8 b(g)f(0)26 b(,)73 b(\045)28 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g
+ (0)122 b(i)43 b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g(0)100 b(t)q(m)q(p)23
+ b(.)f(6)g(\))7 3757 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g
+ (0)100 b(t)q(m)q(p)20 b(.)g(6)g(\))39 b(,)87 b(0)39 b(,)86
+ b(\045)36 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28
+ b(x)11 b(1)g(0)g(0)g(d)g(d)g(e)g(b)g(1)g(0)26 b(\))15
+ 3915 y(f)15 b(m)g(u)g(l)g(s)65 b(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g
+ (0)98 b(t)q(m)q(p)18 b(.)f(1)g(2)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(6)g(b)g(0)92 b(F)-7 b(P)g(V)g(A)g(L)g(2)t(\))
+ 27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)31 b(x)14 b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)95
+ b(t)q(m)q(p)12 b(.)f(1)g(3)g(\))22 b Fh(<)14 4072 y Fo(d)14
+ b(e)g(f)i Fh(>)1 4230 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)95 b(t)q(m)q(p)18
+ b(.)f(1)g(3)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(c)g(b)g(a)g
+ (0)25 b(\))11 4388 y Fi(l)11 b(d)63 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(3)g
+ (0)78 b(T)-18 b(M)g(P)-5 b(\))26 b(,)74 b(\045)30 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(9)g
+ (a)g(0)g(2)g(0)21 b(\))26 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g
+ (0)97 b(t)q(m)q(p)21 b(.)g(1)g(8)g(\))1 4546 y Fi(f)q(m)q(o)q(v)q(s)52
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97 b(t)q(m)q(p)18
+ b(.)f(1)g(8)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(c)g(c)g(4)g
+ (0)30 b(\))-16 4703 y(\045)q(c)18 b(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g
+ (0)24 b(\))79 b(=)90 b(f)11 b(c)g(m)g(p)g(s)60 b(\045)18
+ b(r)e(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97 b(t)q(m)q(p)17
+ b(.)g(1)g(8)g(\))34 b(,)81 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(7)g(3)g
+ (0)90 b(F)-7 b(P)g(V)g(A)g(L)g(3)6 b(\))1 4861 y Fi(f)q(m)q(o)q(v)q(s)
+ 52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(c)g(c)g(4)g(0)29
+ b(\))e(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(4)g(0)27
+ b(\))1 5019 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(c)g(b)g(a)g
+ (0)24 b(\))j(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(e)g(0)26
+ b(\))7 5177 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(e)g(b)g(1)g
+ (0)28 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(a)g(8)g
+ (0)27 b(\))7 5334 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(e)g(b)g(1)g
+ (0)28 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(c)g(f)g(b)g(2)g
+ (0)30 b(\))1 5492 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(d)g(c)g(b)g(a)g(0)24 b(\))j(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(d)g(b)g(e)g(7)g(0)25 b(\))7 5650 y
+ Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(e)g(b)g(1)g(0)28
+ b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(d)g(d)g(b)g(f)g(a)g
+ (0)25 b(\))1 5808 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(d)g(c)g(c)g(4)g(0)29 b(\))e(,)74 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)12
+ b(1)g(0)g(0)g(d)g(d)g(c)g(0)g(4)g(0)23 b(\))23 5965 y(f)h(b)g(l)73
+ b(\045)20 b(c)e(c)g(r)g(e)g(g)33 b(\()f(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g(0)21
+ b(\))27 b(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)34 b(\()j(l)23
+ b(a)e(b)i(e)f(l)124 b(S)17 b(i)g(d)g(e)g(E)g(p)g(i)g(l)g(o)g(g)g(u)g(e)
+ 34 b(\))-2 6123 y Fi(n)n(o)n(p)0 6281 y(ba)51 b Fo(\045)18
+ b(d)f(i)g(s)g(p)34 b(\()j(l)23 b(a)f(b)g(e)g(l)94 b(P)-13
+ b(R)g(O)g(L)g(O)g(G)g(U)g(E)g(2)r(\))-2 6438 y Fi(n)n(o)n(p)-13
+ 6754 y Fo(P)g(R)g(O)g(L)g(O)g(G)g(U)g(E)g(2)-1 6912 y
+ Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)122
+ b(i)43 b(.)20 b(0)g(.)g(0)g(\))39 b(,)87 b(\045)26 b(g)7
+ b(0)26 b(,)73 b(\045)28 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g(0)109
+ b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(:)28 b(P)5 b(h)g(i)g(C)g(p)20
+ b(\))-1 7069 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)35 b(\))g(,)83 b(2)35
+ b(,)83 b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)30 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g(0)105
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))19 7227 y Fi(s)c(r)g(l)71
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g(0)106 b(m)6
+ b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83 b(\045)33
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g(0)117 b(i)18 b(n)g(c)35
+ b(\))6 7385 y Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g(0)118 b(i)18 b(n)g(c)37
+ b(\))d(,)81 b(5)17 b(0)g(0)33 b(,)82 b(\045)24 b(g)7
+ b(0)26 b(,)72 b(\045)30 b(c)18 b(c)g(r)g(e)g(g)33 b(\()g(v)17
+ b(a)g(l)100 b(0)26 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(d)g(0)21
+ b(\))14 7543 y(b)14 b(c)g(s)65 b(\045)20 b(c)e(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(d)g
+ (0)19 b(\))27 b(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)34
+ b(\()j(l)23 b(a)e(b)i(e)f(l)121 b(K)14 b(e)g(r)g(n)g(e)g(l)31
+ b(\))-2 7700 y Fi(n)n(o)n(p)0 7858 y(ba)51 b Fo(\045)18
+ b(d)f(i)g(s)g(p)34 b(\()j(l)23 b(a)f(b)g(e)g(l)99 b(E)-8
+ b(P)g(I)g(L)g(O)g(G)g(U)g(E)s(\))-2 8016 y Fi(n)n(o)n(p)1017
+ 8507 y Fx(Figure)60 b(5.7:)80 b(Mo)5 b(dulo)59 b(Sc)-5
+ b(heduled)60 b(Lo)5 b(op)60 b(for)g(our)h(Sup)5 b(erblo)g(c)-5
+ b(k)60 b(Lo)5 b(op)60 b(\(Prologue\))3809 11136 y(61)p
+ eop end
+ %%Page: 62 69
+ TeXDict begin 62 68 bop 14 1785 a Fo(K)14 b(e)g(r)g(n)g(e)g(l)39
+ b(:)1 1943 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(4)g
+ (0)26 b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(d)g(c)g(f)g(0)g(0)30
+ b(\))1 2101 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)33 b(x)16 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(e)g
+ (0)24 b(\))j(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(d)g(c)g(f)g(a)g(0)30
+ b(\))7 2258 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(a)g(8)g
+ (0)30 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(c)g(e)g(6)g
+ (0)30 b(\))-1 2416 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)31 b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g
+ (0)109 b(i)16 b(n)g(d)g(v)g(a)g(r)40 b(:)28 b(P)5 b(h)g(i)g(C)g(p)19
+ b(\))26 b(,)74 b(\045)20 b(g)7 b(0)26 b(,)72 b(\045)29
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15
+ b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g(0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)32
+ b(\))-1 2574 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)35 b(\))g(,)83 b(1)35
+ b(,)83 b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))-1 2732 y Fi(a)o(d)o(d)48
+ b Fo(\045)8 b(g)f(0)26 b(,)73 b(\045)28 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)114 b(i)16 b(n)g(d)g(v)g(a)g(r)30 b(\))d(,)73 b(\045)30
+ b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100 b(t)q(m)q(p)21
+ b(.)g(1)g(0)g(\))25 2889 y Fi(s)k(l)g(l)75 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(d)g(d)g(c)g(e)g(6)g(0)33 b(\))i(,)83 b(2)35
+ b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101
+ b(0)27 b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(2)g(0)25
+ b(\))15 3047 y(f)15 b(m)g(u)g(l)g(s)65 b(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(d)g(c)g(f)g(0)g
+ (0)29 b(\))e(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(6)g(3)g(0)86
+ b(F)-11 b(P)g(V)g(A)g(L)s(\))27 b(,)73 b(\045)30 b(r)16
+ b(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g
+ (9)g(4)g(9)g(0)97 b(t)q(m)q(p)21 b(.)g(2)g(9)g(\))25
+ 3205 y Fi(s)k(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g(0)100
+ b(t)q(m)q(p)19 b(.)g(1)g(0)g(\))39 b(,)86 b(2)38 b(,)86
+ b(\045)35 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(c)g(0)23 b(\))14
+ 3363 y Fi(s)14 b(t)65 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)31 b(x)14 b(1)g(0)g(0)g(d)g(d)g(c)g(f)g(a)g(0)29
+ b(\))e(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)31 b(x)14 b(1)g(0)g(0)g(c)g(5)g(4)g(7)g(e)g(0)82
+ b(T)-12 b(M)g(P)g(2)r(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(2)g
+ (0)25 b(\))19 3520 y Fi(s)19 b(r)g(l)71 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11
+ b(1)g(0)g(0)g(d)g(d)g(7)g(4)g(8)g(0)101 b(m)6 b(a)g(s)g(k)g(H)g(i)25
+ b(\))35 b(,)83 b(0)35 b(,)83 b(\045)33 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g
+ (0)121 b(i)48 b(.)25 b(0)g(.)g(0)f(\))11 3678 y Fi(l)11
+ b(d)63 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)31 b(x)14 b(1)g(0)g(0)g(c)g(5)g(4)g(7)g(e)g(0)83
+ b(T)-12 b(M)g(P)g(2)q(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(5)g(c)g
+ (0)21 b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g(0)98
+ b(t)q(m)q(p)21 b(.)g(1)g(2)g(\))25 3836 y Fi(s)k(l)g(l)75
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(d)g(c)g(e)g(6)g(0)33 b(\))i(,)83
+ b(2)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31 b(\()h(v)17
+ b(a)g(l)101 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(3)g(0)27
+ b(\))25 3993 y Fi(s)e(l)g(l)75 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(b)g
+ (0)100 b(t)q(m)q(p)19 b(.)g(1)g(0)g(\))39 b(,)86 b(2)38
+ b(,)86 b(\045)35 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(2)g(0)22
+ b(\))14 4151 y Fi(s)14 b(t)65 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(4)g(9)g
+ (0)97 b(t)q(m)q(p)18 b(.)f(2)g(9)g(\))33 b(,)82 b(\045)33
+ b(r)16 b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(3)g(0)78 b(T)-18 b(M)g(P)-6
+ b(\))27 b(,)74 b(\045)29 b(r)16 b(e)g(g)32 b(\()g(v)17
+ b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(3)g(0)28
+ b(\))11 4309 y Fi(l)11 b(d)63 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(5)g(3)g
+ (0)78 b(T)-18 b(M)g(P)-5 b(\))26 b(,)74 b(\045)30 b(r)16
+ b(e)g(g)31 b(\()h(v)17 b(a)g(l)101 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(9)g
+ (a)g(0)g(2)g(0)21 b(\))26 b(,)74 b(\045)29 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g
+ (0)97 b(t)q(m)q(p)21 b(.)g(1)g(8)g(\))1 4467 y Fi(f)q(m)q(o)q(v)q(s)52
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30
+ b(x)13 b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97 b(t)q(m)q(p)18
+ b(.)f(1)g(8)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(4)g
+ (0)27 b(\))15 4624 y(f)15 b(m)g(u)g(l)g(s)65 b(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(8)g(d)g(c)g(0)98 b(t)q(m)q(p)18
+ b(.)f(1)g(2)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(6)g(b)g
+ (0)92 b(F)-7 b(P)g(V)g(A)g(L)g(2)t(\))27 b(,)74 b(\045)29
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)95 b(t)q(m)q(p)21
+ b(.)g(1)g(3)g(\))1 4782 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31 b(x)14
+ b(1)g(0)g(0)g(c)g(5)g(8)g(e)g(4)g(0)95 b(t)q(m)q(p)18
+ b(.)f(1)g(3)g(\))33 b(,)82 b(\045)33 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(e)g
+ (0)25 b(\))-16 4940 y(\045)q(c)18 b(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g
+ (0)24 b(\))79 b(=)90 b(f)11 b(c)g(m)g(p)g(s)60 b(\045)18
+ b(r)e(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)13
+ b(1)g(0)g(0)g(c)g(5)g(9)g(1)g(a)g(0)97 b(t)q(m)q(p)17
+ b(.)g(1)g(8)g(\))34 b(,)81 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()h(v)17 b(a)g(l)100 b(0)30 b(x)13 b(1)g(0)g(0)g(c)g(5)g(8)g(7)g(3)g
+ (0)90 b(F)-7 b(P)g(V)g(A)g(L)g(3)6 b(\))1 5098 y Fi(f)q(m)q(o)q(v)q(s)
+ 52 b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(4)g(0)26
+ b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17 b(a)g(l)100
+ b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(4)g(0)27
+ b(\))1 5255 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(e)g
+ (0)24 b(\))j(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)32 b(x)16 b(1)g(0)g(0)g(d)g(c)g(f)g(9)g(e)g(0)26
+ b(\))1 5413 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(e)g
+ (0)24 b(\))j(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)11 b(1)g(0)g(0)g(d)g(d)g(b)g(e)g(7)g(0)25
+ b(\))1 5571 y Fi(f)q(m)q(o)q(v)q(s)52 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(d)g(0)g(4)g
+ (0)26 b(\))h(,)74 b(\045)29 b(r)16 b(e)g(g)31 b(\()i(v)17
+ b(a)g(l)100 b(0)28 b(x)12 b(1)g(0)g(0)g(d)g(d)g(c)g(0)g(4)g(0)23
+ b(\))23 5729 y(f)h(b)g(l)73 b(\045)20 b(c)e(c)g(r)g(e)g(g)33
+ b(\()f(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(d)g(d)g(7)g(c)g(9)g
+ (0)21 b(\))27 b(,)74 b(\045)30 b(d)17 b(i)g(s)g(p)34
+ b(\()j(l)23 b(a)e(b)i(e)f(l)124 b(S)17 b(i)g(d)g(e)g(E)g(p)g(i)g(l)g(o)
+ g(g)g(u)g(e)34 b(\))-2 5886 y Fi(n)n(o)n(p)0 6044 y(ba)51
+ b Fo(\045)18 b(d)f(i)g(s)g(p)34 b(\()j(l)23 b(a)f(b)g(e)g(l)122
+ b(K)14 b(e)g(r)g(n)g(e)g(l)g(2)30 b(\))-2 6202 y Fi(n)n(o)n(p)14
+ 6517 y Fo(K)14 b(e)g(r)g(n)g(e)g(l)g(2)39 b(:)-1 6675
+ y Fi(a)o(d)o(d)48 b Fo(\045)8 b(g)f(0)26 b(,)73 b(\045)28
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)122 b(i)43 b(.)20
+ b(0)g(.)g(0)g(\))39 b(,)87 b(\045)36 b(r)16 b(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g
+ (0)100 b(t)q(m)q(p)23 b(.)f(6)g(\))7 6833 y Fi(o)7 b(r)58
+ b Fo(\045)17 b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(c)g(5)g(8)g(b)g(5)g(0)100 b(t)q(m)q(p)20
+ b(.)g(6)g(\))39 b(,)87 b(0)39 b(,)86 b(\045)36 b(r)16
+ b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g
+ (d)g(1)g(8)g(0)28 b(\))-1 6991 y Fi(a)o(d)o(d)48 b Fo(\045)18
+ b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(8)g(a)g(b)g(0)122 b(i)43 b(.)20
+ b(0)g(.)g(0)g(\))39 b(,)87 b(\045)26 b(g)7 b(0)26 b(,)73
+ b(\045)28 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)31
+ b(x)15 b(1)g(0)g(0)g(c)g(4)g(e)g(a)g(e)g(0)109 b(i)16
+ b(n)g(d)g(v)g(a)g(r)40 b(:)28 b(P)5 b(h)g(i)g(C)g(p)20
+ b(\))-1 7148 y Fi(a)o(d)o(d)48 b Fo(\045)18 b(r)e(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(c)g(4)g(d)g(f)g(1)g
+ (0)113 b(i)16 b(n)g(d)g(v)g(a)g(r)35 b(\))g(,)83 b(2)35
+ b(,)83 b(\045)33 b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100
+ b(0)30 b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g(0)105
+ b(m)6 b(a)g(s)g(k)g(H)g(i)23 b(\))19 7306 y Fi(s)c(r)g(l)71
+ b Fo(\045)18 b(r)e(e)g(g)31 b(\()i(v)17 b(a)g(l)100 b(0)29
+ b(x)12 b(1)g(0)g(0)g(d)g(9)g(a)g(0)g(c)g(0)106 b(m)6
+ b(a)g(s)g(k)g(H)g(i)25 b(\))35 b(,)83 b(0)35 b(,)83 b(\045)33
+ b(r)16 b(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)30 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g(0)117 b(i)18 b(n)g(c)35
+ b(\))6 7464 y Fi(s)6 b(u)g(b)g(c)g(c)56 b Fo(\045)17
+ b(r)f(e)g(g)32 b(\()g(v)17 b(a)g(l)100 b(0)29 b(x)12
+ b(1)g(0)g(0)g(c)g(5)g(9)g(5)g(d)g(0)118 b(i)18 b(n)g(c)37
+ b(\))d(,)81 b(5)17 b(0)g(0)33 b(,)82 b(\045)24 b(g)7
+ b(0)26 b(,)72 b(\045)30 b(c)18 b(c)g(r)g(e)g(g)33 b(\()g(v)17
+ b(a)g(l)100 b(0)26 b(x)10 b(1)g(0)g(0)g(d)g(d)g(7)g(d)g(d)g(0)21
+ b(\))7 7622 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(d)g(1)g(8)g
+ (0)30 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17 b(a)g(l)100 b(0)32 b(x)15 b(1)g(0)g(0)g(d)g(c)g(f)g(a)g(8)g
+ (0)27 b(\))7 7779 y Fi(o)7 b(r)58 b Fo(\045)17 b(r)f(e)g(g)32
+ b(\()g(v)17 b(a)g(l)100 b(0)27 b(x)10 b(1)g(0)g(0)g(d)g(d)g(d)g(1)g(8)g
+ (0)30 b(\))36 b(,)82 b(0)35 b(,)83 b(\045)34 b(r)16 b(e)g(g)31
+ b(\()i(v)17