Preprocessed source and debug info from compile attempt

compile_error.log (text/plain), 148.75 KB, created by Darrin Smith on 2004-10-25 03:52:53 UTC

************************ Denotes a break between files produced during compile
************************ The name of the file after this break is
************************ elibtool.log

patching file /var/tmp/portage/jpeg-mmx-1.1.2-r1/work/jpeg-mmx/ltmain.sh
Hunk #1 FAILED at 3940.
Hunk #2 FAILED at 4005.
2 out of 2 hunks FAILED -- saving rejects to file /var/tmp/portage/jpeg-mmx-1.1.2-r1/work/jpeg-mmx/ltmain.sh.rej


************************ Denotes a break between files produced during compile
************************ The name of the file after this break is
************************ eclass-debug.log


inherit: libtool -> /usr/portage/eclass/libtool.eclass
inherit: flag-o-matic -> /usr/portage/eclass/flag-o-matic.eclass
inherit: gnuconfig -> /usr/portage/eclass/gnuconfig.eclass
RDEPEND: not set... Setting to: virtual/glibc
inherit: libtool -> /usr/portage/eclass/libtool.eclass
inherit: flag-o-matic -> /usr/portage/eclass/flag-o-matic.eclass
inherit: gnuconfig -> /usr/portage/eclass/gnuconfig.eclass
RDEPEND: not set... Setting to: virtual/glibc
inherit: libtool -> /usr/portage/eclass/libtool.eclass
inherit: flag-o-matic -> /usr/portage/eclass/flag-o-matic.eclass
inherit: gnuconfig -> /usr/portage/eclass/gnuconfig.eclass
RDEPEND: not set... Setting to: virtual/glibc


************************ Denotes a break between files produced during compile
************************ The name of the file after this break is
************************ environment

A=jpeg-mmx-1.1.2.tar.gz
AA=jpeg-mmx-1.1.2.tar.gz
ACCEPT_KEYWORDS=x86
ACCEPT_LICENSE=
ALLOWED_FLAGS='-O -mcpu -march -pipe -g'
ARCH=x86
ARGS=unpack
AUTOCLEAN=yes
BAD=$'\E[31;01m'
BASH=/bin/bash
BASH_ENV=/etc/portage/bashrc
BASH_VERSINFO=([0]="2" [1]="05b" [2]="0" [3]="1" [4]="release" [5]="i686-pc-linux-gnu")
BASH_VERSION='2.05b.0(1)-release'
BRACKET=$'\E[34;01m'
BUILDDIR=/var/tmp/portage/jpeg-mmx-1.1.2-r1
BUILD_PREFIX=/var/tmp/portage
CATEGORY=media-libs
CC=gcc
CCACHE_DIR=/root/.ccache
CCACHE_SIZE=2G
CDEPEND=' '
CFLAGS='-O2 -march=pentium3 -fomit-frame-pointer -pipe'
CHOST=i686-pc-linux-gnu
CLASSPATH=/opt/blackdown-jdk-1.4.1/jre/lib/rt.jar:.
CLEAN_DELAY=5
COLS=-7
COMPILER=gcc3
CONFIG_PROTECT='/usr/lib/mozilla/defaults/pref /usr/X11R6/lib/X11/xkb /usr/kde/3.2/share/config /usr/kde/3.1/share/config /usr/share/config'
CONFIG_PROTECT_MASK='/etc/gconf /etc/env.d'
CVS_RSH=ssh
CXX=g++
CXXFLAGS='-O2 -march=pentium3 -fomit-frame-pointer -pipe'
D=/var/tmp/portage/jpeg-mmx-1.1.2-r1/image/
DEBUGBUILD=
DEPEND=$'virtual/glibc  !bootstrap? ( sys-devel/libtool ) sys-devel/gnuconfig\n\t!bootstrap? ( sys-devel/libtool )'
DESCRIPTION='JPEG library with mmx enhancements'
DESKTOP_SESSION=kde-3.2.0
DESKTOP_STARTUP_ID=0
DESTTREE=/usr
DIROPTIONS=-m0755
DIRSTACK=()
DISPLAY=:0.0
DISTDIR=/home/darrin/Downloads/distfiles
DOCDESTTREE=
EBUILD=/usr/portage/media-libs/jpeg-mmx/jpeg-mmx-1.1.2-r1.ebuild
EBUILD_PHASE=unpack
ECLASS=
ECLASSDIR=/usr/portage/eclass
ECLASS_DEPTH=0
EDITOR=/bin/nano
ELIBTOOL_VERSION=2.0.1
ELT_APPLIED_PATCHES=
ELT_PATCH_DIR=/usr/portage/eclass/ELT-patches
EMERGE_FROM=ebuild
ENDCOL=$'\E[A\E[-7G'
EPATCH_EXCLUDE=
EPATCH_FORCE=no
EPATCH_OPTS=
EPATCH_SINGLE_MSG=
EPATCH_SOURCE=/var/tmp/portage/jpeg-mmx-1.1.2-r1/work/patch
EPATCH_SUFFIX=patch.bz2
EUID=0
EXEDESTTREE=
EXEOPTIONS=-m0755
E_DEPEND=$' !bootstrap? ( sys-devel/libtool ) sys-devel/gnuconfig\n\t!bootstrap? ( sys-devel/libtool )'
FEATURES='ccache sandbox'
FETCHCOMMAND='/usr/bin/wget -t 5 --passive-ftp -P ${DISTDIR} ${URI}'
FILESDIR=/usr/portage/media-libs/jpeg-mmx/files
FTP_PROXY=
GDK_USE_XFT=1
GENTOO_MIRRORS='http://gentoo.oregonstate.edu http://distro.ibiblio.org/pub/Linux/distributions/gentoo'
GLIBC_SSP_CHECKED=1
GOOD=$'\E[32;01m'
GROUPS=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="6" [6]="10" [7]="11" [8]="20" [9]="26" [10]="27")
GS_LIB=/home/darrin/.fonts
GTK2_RC_FILES=/etc/gtk-2.0/gtkrc:/home/darrin/.gtkrc-2.0:/home/darrin/.kde3.2/share/config/gtkrc
GTK_RC_FILES=/etc/gtk/gtkrc:/home/darrin/.gtkrc:/home/darrin/.kde3.2/share/config/gtkrc
G_BROKEN_FILENAMES=1
HILITE=$'\E[36;01m'
HOME=/root
HOMEPAGE=http://mjpeg.sourceforge.net/
HOSTNAME=boris.home.net
HOSTTYPE=i686
HTTP_PROXY=
IFS=$' \t\n'
INFODIR=/usr/share/info:/usr/X11R6/info
INFOPATH=/usr/share/info:/usr/share/gcc-data/i686-pc-linux-gnu/3.3/info
INHERITED=' libtool flag-o-matic gnuconfig libtool flag-o-matic gnuconfig'
INPUTRC=/etc/inputrc
INSDESTTREE=
INSOPTIONS=-m0644
JAVAC=/opt/blackdown-jdk-1.4.1/bin/javac
JAVA_HOME=/opt/blackdown-jdk-1.4.1
JDK_HOME=/opt/blackdown-jdk-1.4.1
KDEDIR=/usr/kde/3.2
KDEDIRS=/usr
KDE_MULTIHEAD=false
KDE_STARTUP_ENV='boris.home.net;1098697116;483047;3541'
KEYWORDS='x86 -ppc -sparc -amd64'
KV=2.4.20-gentoo-r6
KVERS=.
LD_PRELOAD=/lib/libsandbox.so
LESS=-R
LESSOPEN='|lesspipe.sh %s'
LIBOPTIONS=-m0644
LICENSE=as-is
LOGNAME=darrin
MACHTYPE=i686-pc-linux-gnu
MAKEOPTS=-j2
MANPATH=/usr/share/man:/usr/local/share/man:/usr/share/gcc-data/i686-pc-linux-gnu/3.3/man:/usr/X11R6/man:/opt/blackdown-jdk-1.4.1/man:/usr/qt/3/doc/man
MOPREFIX=jpeg-mmx
MOZILLA_FIVE_HOME=/usr/lib/mozilla
NOCOLOR=no
NORMAL=$'\E[0m'
O=/usr/portage/media-libs/jpeg-mmx
OCC=gcc
OCXX=g++
OLDPWD=/var/tmp/portage/jpeg-mmx-1.1.2-r1/work
OPTERR=1
OPTIND=1
OSTYPE=linux-gnu
P=jpeg-mmx-1.1.2
PAGER=/usr/bin/less
PATH=/sbin:/usr/sbin:/usr/lib/portage/bin:/bin:/usr/bin:/usr/local/bin:/opt/bin:/usr/i686-pc-linux-gnu/gcc-bin/3.3:/usr/X11R6/bin:/opt/blackdown-jdk-1.4.1/bin:/opt/blackdown-jdk-1.4.1/jre/bin:/usr/qt/3/bin:/usr/kde/3.2/sbin:/usr/kde/3.2/bin:/usr/kde/3.1/sbin:/usr/kde/3.1/bin
PDEPEND=' '
PF=jpeg-mmx-1.1.2-r1
PIPESTATUS=([0]="0")
PKGDIR=/usr/portage/packages
PKGUSE=
PKG_TMPDIR=/var/tmp/portage-pkg
PN=jpeg-mmx
PORTAGE_BINHOST_CHUNKSIZE=3000
PORTAGE_CACHEDIR=/var/cache/edb/dep/
PORTAGE_CALLER=emerge
PORTAGE_GID=250
PORTAGE_MASTER_PID=10762
PORTAGE_TMPDIR=/var/tmp
PORTDIR=/usr/portage
PPID=10813
PR=r1
PRELINK_PATH=
PRELINK_PATH_MASK=
PS4='+ '
PV=1.1.2
PVR=1.1.2-r1
PWD=/var/tmp/portage/jpeg-mmx-1.1.2-r1
QMAKESPEC=linux-g++
QTDIR=/usr/qt/3
RC_FAIL_ON_ZOMBIE=no
RC_GOT_FUNCTIONS=yes
RC_NET_STRICT_CHECKING=no
RC_NOCOLOR=no
RC_PARALLEL_STARTUP=no
RC_QUIET_STDOUT=no
RC_RETRY_COUNT=5
RC_RETRY_KILL=yes
RC_RETRY_TIMEOUT=1
RDEPEND='virtual/glibc '
RESTRICT=
RESUMECOMMAND='/usr/bin/wget -c -t 5 --passive-ftp -P ${DISTDIR} ${URI}'
ROOT=/
ROOTPATH=/usr/local/bin:/opt/bin:/usr/i686-pc-linux-gnu/gcc-bin/3.3:/usr/X11R6/bin:/opt/blackdown-jdk-1.4.1/bin:/opt/blackdown-jdk-1.4.1/jre/bin:/usr/qt/3/bin:/usr/kde/3.2/sbin:/usr/kde/3.2/bin:/usr/kde/3.1/sbin:/usr/kde/3.1/bin
RPMDIR=/usr/portage/rpm
RSYNC_PROXY=
RSYNC_RETRIES=3
RSYNC_TIMEOUT=180
S=/var/tmp/portage/jpeg-mmx-1.1.2-r1/work/jpeg-mmx
SESSION_MANAGER=local/boris.home.net:/tmp/.ICE-unix/3863
SGML_CATALOG_FILES=/etc/sgml/sgml-ent.cat:/etc/sgml/sgml-docbook.cat:/etc/sgml/openjade-1.3.2.cat:/etc/sgml/sgml-docbook-3.0.cat:/etc/sgml/sgml-docbook-3.1.cat:/etc/sgml/sgml-docbook-4.1.cat:/etc/sgml/dsssl-docbook-stylesheets.cat:/etc/sgml/sgml-docbook-4.0.cat:/etc/sgml/sgml-lite.cat
SHELL=/bin/bash
SHELLOPTS=braceexpand:hashall:interactive-comments
SHLVL=7
SLOT=0
SRC_URI=mirror://sourceforge/mjpeg/jpeg-mmx-1.1.2.tar.gz
STARTDIR=/usr/portage
SVCDIR=/var/lib/supervise
SYNC=rsync://rsync.gentoo.org/gentoo-portage
T=/var/tmp/portage/jpeg-mmx-1.1.2-r1/temp
TERM=dumb
TMP=/var/tmp/portage/jpeg-mmx-1.1.2-r1/temp
TMPDIR=/var/tmp/portage/jpeg-mmx-1.1.2-r1/temp
UID=0
USE='3dnow X aalib alsa apm arts avi berkdb cdr crypt cups directfb encode esd foomaticdb gdbm gif gpm gtk imlib java jpeg kde libg++ libwww mad mikmod mmx motif mozilla mpeg ncurses nls oggvorbis opengl oss pam pdflib perl png python qt quicktime readline sdl slang spell ssl svga tcltk tcpd tetex truetype x86 xml2 xmms xv zlib'
USER=darrin
USERLAND=GNU
USE_EXPAND='VIDEO_CARDS INPUT_DEVICES LINGUAS'
WARN=$'\E[33;01m'
WORKDIR=/var/tmp/portage/jpeg-mmx-1.1.2-r1/work
XARGS='xargs -r'
XAUTHORITY=/tmp/xauth.XXXXz1YT9q
XCURSOR_SIZE=
XCURSOR_THEME=
XDM_MANAGED=/var/run/xdmctl/xdmctl-:0,maysd,mayfn,sched,method=classic
XINITRC=/etc/X11/xinit/xinitrc
_=002
deptypes='need use'
myarg=unpack
ordtypes='before after'
shmdir=/mnt/.shm
svcdir=/var/lib/init.d
svcfstype=tmpfs
svclib=/lib/rcscripts
svcmount=no
svcsize=2048
ELT_find_ltmain_sh () 
{ 
    local x=;
    local dirlist=;
    for x in $(find "${S}" -name 'ltmain.sh');
    do
        dirlist="${dirlist} ${x%/*}";
    done;
    echo "${dirlist}"
}
ELT_try_and_apply_patch () 
{ 
    local ret=0;
    local patch="$2";
    if patch -p0 --dry-run $1 <${patch} >&${T}/elibtool.log; then
        einfo "  Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch...";
        patch -p0 $1 <${patch} >&${T}/elibtool.log;
        ret=$?;
        export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}";
    else
        ret=1;
    fi;
    return ${ret}
}
ELT_walk_patches () 
{ 
    local x=;
    local y=;
    local ret=1;
    local patch_dir=;
    if [ -n "$2" ]; then
        if [ -d "${ELT_PATCH_DIR}/$2" ]; then
            patch_dir="${ELT_PATCH_DIR}/$2";
        else
            return ${ret};
        fi;
        for x in $(ls -d "${patch_dir}"/* 2>/dev/null);
        do
            if [ -n "${x}" -a -f "${x}" ]; then
                if [ -n "$3" ]; then
                    sed -e "s|@REM_INT_DEP@|$3|g" ${x} >${T}/$$.rem_int_deps.patch;
                    x="${T}/$$.rem_int_deps.patch";
                fi;
                if ELT_try_and_apply_patch "$1" "${x}"; then
                    ret=0;
                    break;
                fi;
            fi;
        done;
    fi;
    return ${ret}
}
EXPORT_FUNCTIONS () 
{ 
    if [ -z "$ECLASS" ]; then
        echo "EXPORT_FUNCTIONS without a defined ECLASS" 1>&2;
        exit 1;
    fi;
    while [ "$1" ]; do
        debug-print "EXPORT_FUNCTIONS: ${1} -> ${ECLASS}_${1}";
        eval "$1() { ${ECLASS}_$1 "\$@" ; }" >/dev/null;
        shift;
    done
}
KV_major () 
{ 
    local KV=;
    [ -z "$1" ] && return 1;
    KV="$(echo "$1" | 		awk '{ tmp = $0; gsub(/^[0-9\.]*/, "", tmp); sub(tmp, ""); print }')";
    echo "${KV}" | awk -- 'BEGIN { FS = "." } { print $1 }';
    return 0
}
KV_micro () 
{ 
    local KV=;
    [ -z "$1" ] && return 1;
    KV="$(echo "$1" | 		awk '{ tmp = $0; gsub(/^[0-9\.]*/, "", tmp); sub(tmp, ""); print }')";
    echo "${KV}" | awk -- 'BEGIN { FS = "." } { print $3 }';
    return 0
}
KV_minor () 
{ 
    local KV=;
    [ -z "$1" ] && return 1;
    KV="$(echo "$1" | 		awk '{ tmp = $0; gsub(/^[0-9\.]*/, "", tmp); sub(tmp, ""); print }')";
    echo "${KV}" | awk -- 'BEGIN { FS = "." } { print $2 }';
    return 0
}
KV_to_int () 
{ 
    local KV_MAJOR=;
    local KV_MINOR=;
    local KV_MICRO=;
    local KV_int=;
    [ -z "$1" ] && return 1;
    KV_MAJOR="$(KV_major "$1")";
    KV_MINOR="$(KV_minor "$1")";
    KV_MICRO="$(KV_micro "$1")";
    KV_int="$((KV_MAJOR * 65536 + KV_MINOR * 256 + KV_MICRO))";
    if [ "${KV_int}" -ge 131584 ]; then
        echo "${KV_int}";
        return 0;
    fi;
    return 1
}
abort_compile () 
{ 
    abort_handler "src_compile" $1;
    rm -f "${BUILDDIR}/.compiled";
    exit 1
}
abort_handler () 
{ 
    local msg;
    if [ "$2" != "fail" ]; then
        msg="${EBUILD}: ${1} aborted; exiting.";
    else
        msg="${EBUILD}: ${1} failed; exiting.";
    fi;
    echo;
    echo "$msg";
    echo;
    eval ${3};
    trap SIGINT SIGQUIT
}
abort_install () 
{ 
    abort_handler "src_install" $1;
    rm -rf "${BUILDDIR}/image";
    exit 1
}
abort_package () 
{ 
    abort_handler "dyn_package" $1;
    rm -f "${BUILDDIR}/.packaged";
    rm -f "${PKGDIR}"/All/${PF}.t*;
    exit 1
}
abort_unpack () 
{ 
    abort_handler "src_unpack" $1;
    rm -f "${BUILDDIR}/.unpacked";
    rm -rf "${BUILDDIR}/work";
    exit 1
}
adddeny () 
{ 
    export SANDBOX_DENY="$SANDBOX_DENY:$1"
}
addpredict () 
{ 
    export SANDBOX_PREDICT="$SANDBOX_PREDICT:$1"
}
addread () 
{ 
    export SANDBOX_READ="$SANDBOX_READ:$1"
}
addwrite () 
{ 
    export SANDBOX_WRITE="$SANDBOX_WRITE:$1"
}
append-flags () 
{ 
    export CFLAGS="${CFLAGS} $@";
    export CXXFLAGS="${CXXFLAGS} $@";
    [ "`is-flag -fno-stack-protector`" -o "`is-flag -fno-stack-protector-all`" ] && fstack-flags;
    return 0
}
append-ldflags () 
{ 
    LDFLAGS="${LDFLAGS} $@";
    return 0
}
best_version () 
{ 
    [ "${EBUILD_PHASE}" == "depend" ] && echo "best_version() in global scope: ${CATEGORY}/$PF" 1>&2;
    /usr/lib/portage/bin/portageq 'best_version' "${ROOT}" "$1"
}
check_KV () 
{ 
    if [ -z "${KV}" ]; then
        eerror "";
        eerror "Could not determine your kernel version.";
        eerror "Make sure that you have /usr/src/linux symlink.";
        eerror "And that said kernel has been configured.";
        eerror "You can also simply run the following command";
        eerror "in the kernel referenced by /usr/src/linux:";
        eerror " make include/linux/version.h";
        eerror "";
        diefunc "$FUNCNAME" "$LINENO" "$?";
    fi
}
checkserver () 
{ 
    if get_bootparam "adelie"; then
        [ "$(< "${svcdir}/hostname")" = "(none)" ] || return 1;
    fi;
    return 0
}
debug-print () 
{ 
    [ -z "$T" ] && return 0;
    while [ "$1" ]; do
        if [ "$ECLASS_DEBUG_OUTPUT" == "on" ]; then
            echo "debug: $1";
        else
            if [ -n "$ECLASS_DEBUG_OUTPUT" ]; then
                echo "debug: $1" >>$ECLASS_DEBUG_OUTPUT;
            fi;
        fi;
        echo "$1" >>"${T}/eclass-debug.log";
        chmod g+w "${T}/eclass-debug.log" >&/dev/null;
        shift;
    done
}
debug-print-function () 
{ 
    str="$1: entering function";
    shift;
    debug-print "$str, parameters: $*"
}
debug-print-section () 
{ 
    debug-print "now in section $*"
}
diefunc () 
{ 
    local funcname="$1" lineno="$2" exitcode="$3";
    shift 3;
    echo 1>&2;
    echo "!!! ERROR: $CATEGORY/$PF failed." 1>&2;
    echo "!!! Function $funcname, Line $lineno, Exitcode $exitcode" 1>&2;
    echo "!!! ${*:-(no error message)}" 1>&2;
    echo 1>&2;
    exit 1
}
diropts () 
{ 
    DIROPTIONS="";
    for x in $*;
    do
        DIROPTIONS="${DIROPTIONS} $x";
    done;
    export DIROPTIONS
}
do_newdepend () 
{ 
    debug-print-function do_newdepend $*;
    [ -z "$1" ] && diefunc "$FUNCNAME" "$LINENO" "$?" "do_newdepend without arguments";
    [[ ${ECLASS_DEPTH} > 0 ]] && TARGET="E_$1";
    [[ ${ECLASS_DEPTH} > 0 ]] || TARGET="$1";
    shift;
    while [ -n "$1" ]; do
        eval export ${TARGET}=\"\${${TARGET}} $1\";
        shift;
    done
}
docinto () 
{ 
    if [ "$1" == "/" ]; then
        export DOCDESTTREE="";
    else
        export DOCDESTTREE="$1";
        if [ ! -d "${D}usr/share/doc/${PF}/${DOCDESTTREE}" ]; then
            install -d "${D}usr/share/doc/${PF}/${DOCDESTTREE}";
        fi;
    fi
}
dolisting () 
{ 
    local x=;
    local y=;
    local tmpstr=;
    local mylist=;
    local mypath="${*}";
    if [ "${mypath%/\*}" != "${mypath}" ]; then
        mypath="${mypath%/\*}";
    fi;
    for x in ${mypath};
    do
        [ ! -e "${x}" ] && continue;
        if [ ! -d "${x}" ] && ( [ -L "${x}" -o -f "${x}" ] ); then
            mylist="${mylist} $(ls "${x}" 2> /dev/null)";
        else
            [ "${x%/}" != "${x}" ] && x="${x%/}";
            cd "${x}";
            tmpstr="$(ls)";
            for y in ${tmpstr};
            do
                mylist="${mylist} ${x}/${y}";
            done;
        fi;
    done;
    echo "${mylist}"
}
draw_line () 
{ 
    STR="$*";
    echo ${STR//?/=};
    return 0
}
dyn_clean () 
{ 
    rm -rf "${BUILDDIR}/image";
    rm -rf "${BUILDDIR}/build-info";
    if ! has keeptemp $FEATURES; then
        rm -rf "${T}"/*;
    else
        mv "${T}/environment" "${T}/environment.keeptemp";
    fi;
    if ! has keepwork $FEATURES; then
        rm -rf "${BUILDDIR}/.compiled";
        rm -rf "${BUILDDIR}/.unpacked";
        rm -rf "${WORKDIR}";
    fi;
    if [ -f "${BUILDDIR}/.unpacked" ]; then
        find "${BUILDDIR}" -type d ! -regex "^${WORKDIR}" | sort -r | tr "\n" "\0" | $XARGS -0 rmdir >&/dev/null;
    fi;
    true
}
dyn_compile () 
{ 
    trap "abort_compile" SIGINT SIGQUIT;
    [ "${CFLAGS-unset}" != "unset" ] && export CFLAGS;
    [ "${CXXFLAGS-unset}" != "unset" ] && export CXXFLAGS;
    [ "${LIBCFLAGS-unset}" != "unset" ] && export LIBCFLAGS;
    [ "${LIBCXXFLAGS-unset}" != "unset" ] && export LIBCXXFLAGS;
    [ "${LDFLAGS-unset}" != "unset" ] && export LDFLAGS;
    [ "${ASFLAGS-unset}" != "unset" ] && export ASFLAGS;
    [ "${DISTCC_DIR-unset}" == "unset" ] && export DISTCC_DIR="${PORTAGE_TMPDIR}/.distcc";
    [ ! -z "${DISTCC_DIR}" ] && addwrite "${DISTCC_DIR}";
    if has noauto $FEATURES >&/dev/null && [ ! -f ${BUILDDIR}/.unpacked ]; then
        echo;
        echo "!!! We apparently haven't unpacked... This is probably not what you";
        echo "!!! want to be doing... You are using FEATURES=noauto so I'll assume";
        echo "!!! that you know what you are doing... You have 5 seconds to abort...";
        echo;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0.25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        echo -ne "\a";
        sleep 0,25 >&/dev/null;
        sleep 3;
    fi;
    cd "${BUILDDIR}";
    if [ ! -e "build-info" ]; then
        mkdir build-info;
    fi;
    cp "${EBUILD}" "build-info/${PF}.ebuild";
    if [ ${BUILDDIR}/.compiled -nt "${WORKDIR}" ]; then
        echo ">>> It appears that ${PN} is already compiled; skipping.";
        echo ">>> (clean to force compilation)";
        trap SIGINT SIGQUIT;
        return;
    fi;
    if [ -d "${S}" ]; then
        cd "${S}";
    fi;
    export S D;
    export PWORKDIR="$WORKDIR";
    src_compile;
    cd "${BUILDDIR}";
    touch .compiled;
    cd build-info;
    echo "$CBUILD" >CBUILD;
    echo "$CC" >CC;
    echo "$CDEPEND" >CDEPEND;
    echo "$CFLAGS" >CFLAGS;
    echo "$CHOST" >CHOST;
    echo "$CXX" >CXX;
    echo "$CXXFLAGS" >CXXFLAGS;
    echo "$DEPEND" >DEPEND;
    echo "$IUSE" >IUSE;
    echo "$PKGUSE" >PKGUSE;
    echo "$LICENSE" >LICENSE;
    echo "$CATEGORY" >CATEGORY;
    echo "$PDEPEND" >PDEPEND;
    echo "$PF" >PF;
    echo "$PROVIDE" >PROVIDE;
    echo "$RDEPEND" >RDEPEND;
    echo "$SLOT" >SLOT;
    echo "$USE" >USE;
    set | bzip2 -9 - >environment.bz2;
    cp "${EBUILD}" "${PF}.ebuild";
    if has nostrip $FEATURES $RESTRICT; then
        touch DEBUGBUILD;
    fi;
    trap SIGINT SIGQUIT
}
dyn_help () 
{ 
    echo;
    echo "Portage";
    echo "Copyright 2002 Gentoo Technologies, Inc.";
    echo;
    echo "How to use the ebuild command:";
    echo;
    echo "The first argument to ebuild should be an existing .ebuild file.";
    echo;
    echo "One or more of the following options can then be specified.  If more";
    echo "than one option is specified, each will be executed in order.";
    echo;
    echo "  setup       : execute package specific setup actions";
    echo "  fetch       : download source archive(s) and patches";
    echo "  unpack      : unpack/patch sources (auto-fetch if needed)";
    echo "  compile     : compile sources (auto-fetch/unpack if needed)";
    echo "  merge       : merge image into live filesystem, recording files in db";
    echo "                (auto-fetch/unpack/compile if needed)";
    echo "  unmerge     : remove package from live filesystem";
    echo "  package     : create tarball package of type ${PACKAGE}";
    echo "                (will be stored in ${PKGDIR}/All)";
    echo "  clean       : clean up all source and temporary files";
    echo;
    echo "The following settings will be used for the ebuild process:";
    echo;
    echo "  package     : ${PF}";
    echo "  slot        : ${SLOT}";
    echo "  category    : ${CATEGORY}";
    echo "  description : ${DESCRIPTION}";
    echo "  system      : ${CHOST}";
    echo "  c flags     : ${CFLAGS}";
    echo "  c++ flags   : ${CXXFLAGS}";
    echo "  make flags  : ${MAKEOPTS}";
    echo -n "  build mode  : ";
    if has nostrip $FEATURES $RESTRICT; then
        echo "debug (large)";
    else
        echo "production (stripped)";
    fi;
    echo "  merge to    : ${ROOT}";
    echo;
    if [ -n "$USE" ]; then
        echo "Additionally, support for the following optional features will be enabled:";
        echo;
        echo "  ${USE}";
    fi;
    echo
}
dyn_install () 
{ 
    trap "abort_install" SIGINT SIGQUIT;
    rm -rf "${BUILDDIR}/image";
    mkdir "${BUILDDIR}/image";
    if [ -d "${S}" ]; then
        cd "${S}";
    fi;
    echo;
    echo ">>> Install ${PF} into ${D} category ${CATEGORY}";
    export S D;
    export PWORKDIR="$WORKDIR";
    src_install;
    prepall;
    cd "${D}";
    declare -i UNSAFE=0;
    for i in $(find "${D}/" -type f -perm -2002);
    do
        UNSAFE=$(($UNSAFE + 1));
        echo "UNSAFE SetGID: $i";
    done;
    for i in $(find "${D}/" -type f -perm -4002);
    do
        UNSAFE=$(($UNSAFE + 1));
        echo "UNSAFE SetUID: $i";
    done;
    if [[ $UNSAFE > 0 ]]; then
        diefunc "$FUNCNAME" "$LINENO" "$?" "There are ${UNSAFE} unsafe files. Portage will not install them.";
    fi;
    find "${D}/" -user portage -print0 | $XARGS -0 -n100 chown root;
    if [ "$USERLAND" == "BSD" ]; then
        find "${D}/" -group portage -print0 | $XARGS -0 -n100 chgrp wheel;
    else
        find "${D}/" -group portage -print0 | $XARGS -0 -n100 chgrp root;
    fi;
    echo ">>> Completed installing into ${D}";
    echo;
    cd ${BUILDDIR};
    trap SIGINT SIGQUIT
}
dyn_package () 
{ 
    trap "abort_package" SIGINT SIGQUIT;
    cd "${BUILDDIR}/image";
    tar cpvf - ./ | bzip2 -f >../bin.tar.bz2 || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to create tarball";
    cd ..;
    xpak build-info inf.xpak;
    tbz2tool join bin.tar.bz2 inf.xpak "${PF}.tbz2";
    mv "${PF}.tbz2" "${PKGDIR}/All" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to move tbz2 to ${PKGDIR}/All";
    rm -f inf.xpak bin.tar.bz2;
    if [ ! -d "${PKGDIR}/${CATEGORY}" ]; then
        install -d "${PKGDIR}/${CATEGORY}";
    fi;
    ln -sf "../All/${PF}.tbz2" "${PKGDIR}/${CATEGORY}/${PF}.tbz2" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to create symlink in ${PKGDIR}/${CATEGORY}";
    echo ">>> Done.";
    cd "${BUILDDIR}";
    touch .packaged || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to 'touch .packaged' in ${BUILDDIR}";
    trap SIGINT SIGQUIT
}
dyn_preinst () 
{ 
    [ "${EMERGE_FROM}" == "binary" ] && IMAGE=${PKG_TMPDIR}/${PF}/bin || IMAGE=${D};
    pkg_preinst;
    if has noman $FEATURES; then
        rm -fR "${IMAGE}/usr/share/man";
    fi;
    if has noinfo $FEATURES; then
        rm -fR "${IMAGE}/usr/share/info";
    fi;
    if has nodoc $FEATURES; then
        rm -fR "${IMAGE}/usr/share/doc";
    fi;
    if has sfperms $FEATURES; then
        for i in $(find ${IMAGE}/ -type f -perm -4000);
        do
            ebegin ">>> SetUID: [chmod go-r] $i ";
            chmod go-r "$i";
            eend $?;
        done;
        for i in $(find ${IMAGE}/ -type f -perm -2000);
        do
            ebegin ">>> SetGID: [chmod o-r] $i ";
            chmod o-r "$i";
            eend $?;
        done;
    fi;
    if has suidctl $FEATURES >/dev/null; then
        sfconf=/etc/portage/suidctl.conf;
        echo ">>> Preforming suid scan in ${IMAGE}";
        for i in $(find ${IMAGE}/ -type f \( -perm -4000 -o -perm -2000 \) );
        do
            if [ -s "${sfconf}" ]; then
                suid="`grep ^${i/${IMAGE}/}$ ${sfconf}`";
                if [ "${suid}" = "${i/${IMAGE}/}" ]; then
                    echo "- ${i/${IMAGE}/} is an approved suid file";
                else
                    for x in 5 4 3 2 1 0;
                    do
                        echo -ne "\a";
                        sleep 0.25;
                    done;
                    echo ">>> Removing sbit on non registered ${i/${IMAGE}/}";
                    echo -ne "\a";
                    chmod ugo-s "${i}";
                    grep ^#${i/${IMAGE}/}$ ${sfconf} >/dev/null || { 
                        addwrite "${sfconf}";
                        echo ">>> Appending commented out entry to ${sfconf} for ${PF}";
                        ls -ldh "${i}" | awk '{print "## "$0}' | sed s:"${IMAGE}"::g >>${sfconf};
                        echo "#${i/${IMAGE}/}" >>${sfconf}
                    };
                fi;
            else
                echo "suidctl feature set but you are lacking a ${sfconf}";
            fi;
        done;
    fi;
    if use selinux; then
        if [ -f /selinux/context -a -x /usr/sbin/setfiles ]; then
            echo ">>> Setting SELinux security labels";
            if [ -f ${POLICYDIR}/file_contexts/file_contexts ]; then
                cp -f "${POLICYDIR}/file_contexts/file_contexts" "${T}";
            else
                make -C "${POLICYDIR}" FC=${T}/file_contexts "${T}/file_contexts";
            fi;
            addwrite /selinux/context;
            /usr/sbin/setfiles -r "${IMAGE}" "${T}/file_contexts" "${IMAGE}" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to set SELinux security labels.";
        else
            echo "!!! Unable to set SELinux security labels";
        fi;
    fi;
    trap SIGINT SIGQUIT
}
dyn_rpm () 
{ 
    dyn_spec;
    rpm -bb "${PF}.spec" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to integrate rpm spec file";
    install -D "/usr/src/redhat/RPMS/i386/${PN}-${PV}-${PR}.i386.rpm" "${RPMDIR}/${CATEGORY}/${PN}-${PV}-${PR}.rpm" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to move rpm"
}
dyn_setup () 
{ 
    if [ "$USERLAND" == "Linux" ]; then
        if [ "${DISABLE_GEN_GCC_WRAPPERS}" != "yes" ]; then
            if [ -L /lib/cpp -o ! -e /lib/cpp ]; then
                [ -L /lib/cpp ] && rm -f /lib/cpp;
                gen_wrapper /lib/cpp cpp;
            fi;
            if [ -L /usr/bin/cc -o ! -e /usr/bin/cc ]; then
                [ -L /usr/bin/cc ] && rm -f /usr/bin/cc;
                gen_wrapper /usr/bin/cc gcc;
            fi;
        fi;
    fi;
    pkg_setup
}
dyn_spec () 
{ 
    tar czf "/usr/src/redhat/SOURCES/${PF}.tar.gz" "${O}/${PF}.ebuild" "${O}/files" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to create base rpm tarball.";
    cat  >${PF}.spec <<__END1__
Summary: ${DESCRIPTION}
Name: ${PN}
Version: ${PV}
Release: ${PR}
Copyright: GPL
Group: portage/${CATEGORY}
Source: ${PF}.tar.gz
Buildroot: ${D}
%description
${DESCRIPTION}

${HOMEPAGE}

%prep
%setup -c

%build

%install

%clean

%files
/
__END1__

}
dyn_unpack () 
{ 
    trap "abort_unpack" SIGINT SIGQUIT;
    local newstuff="no";
    if [ -e "${WORKDIR}" ]; then
        local x;
        local checkme;
        for x in ${AA};
        do
            echo ">>> Checking ${x}'s mtime...";
            if [ "${DISTDIR}/${x}" -nt "${WORKDIR}" ]; then
                echo ">>> ${x} has been updated; recreating WORKDIR...";
                newstuff="yes";
                rm -rf "${WORKDIR}";
                break;
            fi;
        done;
        if [ "${EBUILD}" -nt "${WORKDIR}" ]; then
            echo ">>> ${EBUILD} has been updated; recreating WORKDIR...";
            newstuff="yes";
            rm -rf "${WORKDIR}";
        else
            if [ ! -f "${BUILDDIR}/.unpacked" ]; then
                echo ">>> Not marked as unpacked; recreating WORKDIR...";
                newstuff="yes";
                rm -rf "${WORKDIR}";
            fi;
        fi;
    fi;
    if [ -e "${WORKDIR}" ]; then
        if [ "$newstuff" == "no" ]; then
            echo ">>> WORKDIR is up-to-date, keeping...";
            return 0;
        fi;
    fi;
    install -m0700 -d "${WORKDIR}" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to create dir '${WORKDIR}'";
    [ -d "$WORKDIR" ] && cd "${WORKDIR}";
    echo ">>> Unpacking source...";
    src_unpack;
    touch "${BUILDDIR}/.unpacked" || diefunc "$FUNCNAME" "$LINENO" "$?" "IO Failure -- Failed 'touch .unpacked' in BUILDIR";
    echo ">>> Source unpacked.";
    cd "$BUILDDIR";
    trap SIGINT SIGQUIT
}
ebegin () 
{ 
    if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
        if [ "${RC_NOCOLOR}" = "yes" ]; then
            echo -ne " ${GOOD}*${NORMAL} ${*}...";
        else
            echo -e " ${GOOD}*${NORMAL} ${*}...";
        fi;
    fi;
    return 0
}
econf () 
{ 
    if [ -x ./configure ]; then
        if [ ! -z "${CBUILD}" ]; then
            EXTRA_ECONF="--build=${CBUILD} ${EXTRA_ECONF}";
        fi;
        ./configure --prefix=/usr --host=${CHOST} --mandir=/usr/share/man --infodir=/usr/share/info --datadir=/usr/share --sysconfdir=/etc --localstatedir=/var/lib ${EXTRA_ECONF} "$@" || diefunc "$FUNCNAME" "$LINENO" "$?" "econf failed";
    else
        diefunc "$FUNCNAME" "$LINENO" "$?" "no configure script found";
    fi
}
edos2unix () 
{ 
    for f in $@;
    do
        cp ${f} ${T}/edos2unix;
        sed 's/\r$//' ${T}/edos2unix >${f};
        rm -f ${T}/edos2unix;
    done
}
eend () 
{ 
    local retval=;
    if [ "$#" -eq 0 ] || ( [ -n "$1" ] && [ "$1" -eq 0 ] ); then
        if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
            echo -e "${ENDCOL}  ${BRACKET}[ ${GOOD}ok${BRACKET} ]${NORMAL}";
        fi;
    else
        retval="$1";
        if [ "$#" -ge 2 ]; then
            shift;
            eerror "${*}";
        fi;
        if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
            echo -e "${ENDCOL}  ${BRACKET}[ ${BAD}!!${BRACKET} ]${NORMAL}";
            echo;
        fi;
        return ${retval};
    fi;
    return 0
}
eerror () 
{ 
    if [ "${RC_QUIET_STDOUT}" = "yes" ]; then
        echo " ${*}" >/dev/stderr;
    else
        echo -e " ${BAD}*${NORMAL} ${*}";
    fi;
    esyslog "daemon.err" "rc-scripts" "${*}";
    return 0
}
einfo () 
{ 
    if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
        echo -e " ${GOOD}*${NORMAL} ${*}";
    fi;
    return 0
}
einfon () 
{ 
    if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
        echo -ne " ${GOOD}*${NORMAL} ${*}";
    fi;
    return 0
}
einstall () 
{ 
    if [ -f ./[mM]akefile -o -f ./GNUmakefile ]; then
        if [ ! -z "${PORTAGE_DEBUG}" ]; then
            make -n prefix=${D}/usr datadir=${D}/usr/share infodir=${D}/usr/share/info localstatedir=${D}/var/lib mandir=${D}/usr/share/man sysconfdir=${D}/etc "$@" install;
        fi;
        make prefix=${D}/usr datadir=${D}/usr/share infodir=${D}/usr/share/info localstatedir=${D}/var/lib mandir=${D}/usr/share/man sysconfdir=${D}/etc "$@" install || diefunc "$FUNCNAME" "$LINENO" "$?" "einstall failed";
    else
        diefunc "$FUNCNAME" "$LINENO" "$?" "no Makefile found";
    fi
}
elibtoolize () 
{ 
    local x=;
    local y=;
    local do_portage="no";
    local do_reversedeps="no";
    local do_only_patches="no";
    local deptoremove=;
    local my_dirlist=;
    local elt_patches="portage relink max_cmd_len sed test tmp";
    my_dirlist="$(ELT_find_ltmain_sh)";
    for x in $*;
    do
        case "${x}" in 
            "--portage")
                do_portage="yes"
            ;;
            "--reverse-deps")
                do_reversedeps="yes";
                elt_patches="${elt_patches} fix-relink"
            ;;
            "--patch-only")
                do_only_patches="yes"
            ;;
            "^--remove-internal-dep="*)
                deptoremove="$(echo "${x}" | sed -e 's|--remove-internal-dep=||')";
                [ -n "${deptoremove}" ] && elt_patches="${elt_patches} rem-int-dep"
            ;;
            "--shallow")
                if [ -f "${S}/ltmain.sh" ]; then
                    my_dirlist="${S}";
                else
                    my_dirlist=;
                fi
            ;;
        esac;
    done;
    for x in ${my_dirlist};
    do
        local tmp="$(echo "${x}" | sed -e "s|${S}||")";
        export ELT_APPLIED_PATCHES=;
        cd ${x};
        einfo "Patching \${S}$(echo "/${tmp}/ltmain.sh" | sed -e 's|//|/|g')...";
        for y in ${elt_patches};
        do
            local ret=0;
            case "${y}" in 
                "rem-int-dep")
                    ELT_walk_patches "${x}/ltmain.sh" "${y}" "${deptoremove}";
                    ret=$?
                ;;
                "fix-relink")
                    if [ -n "$(grep 'inst_prefix_dir' "${x}/ltmain.sh")" ]; then
                        ELT_walk_patches "${x}/ltmain.sh" "${y}";
                        ret=$?;
                    fi
                ;;
                "max_cmd_len")
                    if [ -n "$(grep 'max_cmd_len' "${x}/ltmain.sh")" ]; then
                        ELT_walk_patches "${x}/ltmain.sh" "${y}";
                        ret=$?;
                    fi
                ;;
                *)
                    ELT_walk_patches "${x}/ltmain.sh" "${y}";
                    ret=$?
                ;;
            esac;
            if [ "${ret}" -ne 0 ]; then
                case ${y} in 
                    "relink")
                        if [ -z "$(grep 'inst_prefix_dir' "${x}/ltmain.sh")" ]; then
                            ewarn "  Could not apply relink.patch!";
                        fi
                    ;;
                    "portage")
                        if [ "${do_portage}" = "yes" ]; then
                            if [ -z "$(grep 'We do not want portage' "${x}/ltmain.sh")" ]; then
                                echo;
                                eerror "Portage patch requested, but failed to apply!";
                                diefunc "$FUNCNAME" "$LINENO" "$?" "Portage patch requested, but failed to apply!";
                            fi;
                        else
                            ewarn "  Could not apply portage.patch!";
                            ewarn "  Please verify that it is not needed.";
                        fi
                    ;;
                esac;
            fi;
            if [ -z "${ELT_APPLIED_PATCHES}" ]; then
                if [ "${do_portage}" = "no" -a "${do_reversedeps}" = "no" -a "${do_only_patches}" = "no" -a "${deptoremove}" = "" ]; then
                    if [ ! -f ${x}/configure.in -a ! -f ${x}/configure.ac ]; then
                        if [ -f ${x}/../configure.in -o -f ${x}/../configure.ac ]; then
                            cd ${x}/../;
                        fi;
                    fi;
                    if which libtoolize >&/dev/null; then
                        ewarn "Cannot apply any patch, running libtoolize...";
                        libtoolize --copy --force;
                    fi;
                    cd ${x};
                    break;
                fi;
            fi;
        done;
    done;
    if [ -f libtool ]; then
        rm -f libtool;
    fi;
    cd ${S}
}
enewgroup () 
{ 
    local egroup="$1";
    shift;
    if [ -z "${egroup}" ]; then
        eerror "No group specified !";
        diefunc "$FUNCNAME" "$LINENO" "$?" "Cannot call enewgroup without a group";
    fi;
    einfo "Adding group '${egroup}' to your system ...";
    if which mktemp >&/dev/null; then
        local tmpfile="`mktemp -p ${T}`";
        touch ${tmpfile};
        chgrp ${egroup} ${tmpfile} 1>&/dev/null;
        local realgroup="`ls -l ${tmpfile} | awk '{print $4}'`";
        if [ "${egroup}" == "${realgroup}" ]; then
            einfo "${egroup} already exists on your system :)";
            return 0;
        fi;
    else
        if egrep -q "^${egroup}:"; then
            einfo "${egroup} already exists on your system :)";
            return 0;
        fi;
    fi;
    local opts="";
    local egid="$1";
    shift;
    if [ ! -z "${egid}" ]; then
        if [ ${egid} -gt 0 ]; then
            opts="${opts} -g ${egid}";
        else
            eerror "Groupid given but is not greater than 0 !";
            diefunc "$FUNCNAME" "$LINENO" "$?" "${egid} is not a valid GID";
        fi;
    else
        egid="next available";
    fi;
    einfo " - Groupid: ${egid}";
    local eextra="$@";
    opts="${opts} ${eextra}";
    local oldsandbox="${oldsandbox}";
    export SANDBOX_ON="0";
    groupadd ${opts} ${egroup} || diefunc "$FUNCNAME" "$LINENO" "$?" "enewgroup failed";
    export SANDBOX_ON="${oldsandbox}"
}
enewuser () 
{ 
    local euser="$1";
    shift;
    if [ -z "${euser}" ]; then
        eerror "No username specified !";
        diefunc "$FUNCNAME" "$LINENO" "$?" "Cannot call enewuser without a username";
    fi;
    einfo "Adding user '${euser}' to your system ...";
    if which mktemp >&/dev/null; then
        local tmpfile="`mktemp -p ${T}`";
        touch ${tmpfile};
        chown ${euser} ${tmpfile} 1>&/dev/null;
        local realuser="`ls -l ${tmpfile} | awk '{print $3}'`";
    fi;
    if [ ! -z "${realuser}" ]; then
        if [ "${euser}" == "${realuser}" ]; then
            einfo "${euser} already exists on your system :)";
            return 0;
        fi;
    else
        if id "${euser}"; then
            einfo "${euser} already exists on your system :)";
            return 0;
        fi;
    fi;
    local opts="";
    local euid="$1";
    shift;
    if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ]; then
        if [ ${euid} -gt 0 ]; then
            opts="${opts} -u ${euid}";
        else
            eerror "Userid given but is not greater than 0 !";
            diefunc "$FUNCNAME" "$LINENO" "$?" "${euid} is not a valid UID";
        fi;
    else
        euid="next available";
    fi;
    einfo " - Userid: ${euid}";
    local eshell="$1";
    shift;
    if [ ! -z "${eshell}" ]; then
        if [ ! -e ${eshell} ]; then
            eerror "A shell was specified but it does not exist !";
            diefunc "$FUNCNAME" "$LINENO" "$?" "${eshell} does not exist";
        fi;
    else
        eshell=/bin/false;
    fi;
    einfo " - Shell: ${eshell}";
    opts="${opts} -s ${eshell}";
    local ehome="$1";
    shift;
    if [ -z "${ehome}" ]; then
        ehome=/dev/null;
    fi;
    einfo " - Home: ${ehome}";
    opts="${opts} -d ${ehome}";
    local egroups="$1";
    shift;
    if [ ! -z "${egroups}" ]; then
        local realgroup;
        local oldifs="${IFS}";
        export IFS=",";
        for g in ${egroups};
        do
            if which mktemp >&/dev/null; then
                chgrp ${g} ${tmpfile} 1>&/dev/null;
                realgroup="`ls -l ${tmpfile} | awk '{print $4}'`";
                if [ "${g}" != "${realgroup}" ]; then
                    eerror "You must add ${g} to the system first";
                    diefunc "$FUNCNAME" "$LINENO" "$?" "${g} is not a valid GID";
                fi;
            else
                if ! egrep -q "^${g}:"; then
                    eerror "You must add ${g} to the system first";
                    diefunc "$FUNCNAME" "$LINENO" "$?" "${g} is not a valid GID";
                fi;
            fi;
        done;
        export IFS="${oldifs}";
        opts="${opts} -g ${egroups}";
    else
        egroups="(none)";
    fi;
    einfo " - Groups: ${egroups}";
    local eextra="$@";
    local oldsandbox="${oldsandbox}";
    export SANDBOX_ON="0";
    if [ -z "${eextra}" ]; then
        useradd ${opts} ${euser} -c "added by portage for ${PN}" || diefunc "$FUNCNAME" "$LINENO" "$?" "enewuser failed";
    else
        einfo " - Extra: ${eextra}";
        useradd ${opts} ${euser} ${eextra} || diefunc "$FUNCNAME" "$LINENO" "$?" "enewuser failed";
    fi;
    export SANDBOX_ON="${oldsandbox}";
    if [ ! -e ${ehome} ] && [ ! -e ${D}/${ehome} ]; then
        einfo " - Creating ${ehome} in ${D}";
        dodir ${ehome};
        fperms ${euser} ${ehome};
    fi
}
epatch () 
{ 
    echo "RUNNING FROM extra_functions.sh";
    local PIPE_CMD="";
    local STDERR_TARGET="${T}/$$.out";
    local PATCH_TARGET="${T}/$$.patch";
    local PATCH_SUFFIX="";
    local SINGLE_PATCH="no";
    local x="";
    if [ "$#" -gt 1 ]; then
        eerror "Invalid arguments to epatch()";
        diefunc "$FUNCNAME" "$LINENO" "$?" "Invalid arguments to epatch()";
    fi;
    if [ -n "$1" -a -f "$1" ]; then
        SINGLE_PATCH="yes";
        local EPATCH_SOURCE="$1";
        local EPATCH_SUFFIX="${1##*\.}";
    else
        if [ -n "$1" -a -d "$1" ]; then
            if [ "${EPATCH_FORCE}" = "yes" ] && [ -z "${EPATCH_SUFFIX}" ]; then
                local EPATCH_SOURCE="$1/*";
            else
                local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}";
            fi;
        else
            if [ ! -d ${EPATCH_SOURCE} ]; then
                if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]; then
                    EPATCH_SOURCE="$1";
                fi;
                echo;
                eerror "Cannot find \$EPATCH_SOURCE!  Value for \$EPATCH_SOURCE is:";
                eerror;
                eerror "  ${EPATCH_SOURCE}";
                echo;
                diefunc "$FUNCNAME" "$LINENO" "$?" "Cannot find \$EPATCH_SOURCE!";
            fi;
            local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}";
        fi;
    fi;
    case ${EPATCH_SUFFIX##*\.} in 
        bz2)
            PIPE_CMD="bzip2 -dc";
            PATCH_SUFFIX="bz2"
        ;;
        gz | Z | z)
            PIPE_CMD="gzip -dc";
            PATCH_SUFFIX="gz"
        ;;
        ZIP | zip)
            PIPE_CMD="unzip -p";
            PATCH_SUFFIX="zip"
        ;;
        *)
            PIPE_CMD="cat";
            PATCH_SUFFIX="patch"
        ;;
    esac;
    if [ "${SINGLE_PATCH}" = "no" ]; then
        einfo "Applying various patches (bugfixes/updates)...";
    fi;
    for x in ${EPATCH_SOURCE};
    do
        if [ -f ${x} ] && ( [ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] || [ "${EPATCH_FORCE}" = "yes" ] ); then
            local count=0;
            local popts="${EPATCH_OPTS}";
            if [ -n "${EPATCH_EXCLUDE}" ]; then
                if [ "`eval echo \$\{EPATCH_EXCLUDE/${x##*/}\}`" != "${EPATCH_EXCLUDE}" ]; then
                    continue;
                fi;
            fi;
            if [ "${SINGLE_PATCH}" = "yes" ]; then
                if [ -n "${EPATCH_SINGLE_MSG}" ]; then
                    einfo "${EPATCH_SINGLE_MSG}";
                else
                    einfo "Applying ${x##*/}...";
                fi;
            else
                einfo "  ${x##*/}...";
            fi;
            echo "***** ${x##*/} *****" >${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
            echo >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
            while [ "${count}" -lt 5 ]; do
                draw_line "***** ${x##*/} *****" >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                echo >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                if [ "${PATCH_SUFFIX}" != "patch" ]; then
                    echo -n "PIPE_COMMAND:  " >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                    echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                else
                    PATCH_TARGET="${x}";
                fi;
                echo -n "PATCH COMMAND:  " >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                echo "patch ${popts} -p${count} < ${PATCH_TARGET}" >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                echo >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                draw_line "***** ${x##*/} *****" >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                if [ "${PATCH_SUFFIX}" != "patch" ]; then
                    if ! ( ${PIPE_CMD} ${x} >${PATCH_TARGET} ) >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/} 2>&1; then
                        echo;
                        eerror "Could not extract patch!";
                        count=5;
                        break;
                    fi;
                fi;
                if ( cat ${PATCH_TARGET} | patch ${popts} --dry-run -f -p${count} ) >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/} 2>&1; then
                    draw_line "***** ${x##*/} *****" >${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    echo >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    echo "ACTUALLY APPLYING ${x##*/}..." >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    echo >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    draw_line "***** ${x##*/} *****" >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    cat ${PATCH_TARGET} | patch ${popts} -p${count} >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real 2>&1;
                    if [ "$?" -ne 0 ]; then
                        cat ${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real >>${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
                        echo;
                        eerror "A dry-run of patch command succeeded, but actually";
                        eerror "applying the patch failed!";
                        count=5;
                    fi;
                    rm -f ${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}.real;
                    break;
                fi;
                count=$((count + 1));
            done;
            if [ "${PATCH_SUFFIX}" != "patch" ]; then
                rm -f ${PATCH_TARGET};
            fi;
            if [ "${count}" -eq 5 ]; then
                echo;
                eerror "Failed Patch: ${x##*/}!";
                eerror;
                eerror "Include in your bugreport the contents of:";
                eerror;
                eerror "  ${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/}";
                echo;
                diefunc "$FUNCNAME" "$LINENO" "$?" "Failed Patch: ${x##*/}!";
            fi;
            rm -f ${STDERR_TARGET%/*}/${x##*/}-${STDERR_TARGET##*/};
            eend 0;
        fi;
    done;
    if [ "${SINGLE_PATCH}" = "no" ]; then
        einfo "Done with patching";
    fi
}
esyslog () 
{ 
    return 0
}
etexec-flags () 
{ 
    has_pie || has_pic;
    if [ $? == 0 ]; then
        [ -z "`is-flag -yet_exec`" ] && export CFLAGS="${CFLAGS} `test_flag -yet_exec`";
        [ -z "`is-flag -nopie`" ] && export CFLAGS="${CFLAGS} `test_flag -nopie`";
    fi
}
ewarn () 
{ 
    if [ "${RC_QUIET_STDOUT}" = "yes" ]; then
        echo " ${*}";
    else
        echo -e " ${WARN}*${NORMAL} ${*}";
    fi;
    esyslog "daemon.warning" "rc-scripts" "${*}";
    return 0
}
ewend () 
{ 
    local retval=;
    if [ "$#" -eq 0 ] || ( [ -n "$1" ] && [ "$1" -eq 0 ] ); then
        if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
            echo -e "${ENDCOL}  ${BRACKET}[ ${GOOD}ok${BRACKET} ]${NORMAL}";
        fi;
    else
        retval="$1";
        if [ "$#" -ge 2 ]; then
            shift;
            ewarn "${*}";
        fi;
        if [ "${RC_QUIET_STDOUT}" != "yes" ]; then
            echo -e "${ENDCOL}  ${BRACKET}[ ${WARN}!!${BRACKET} ]${NORMAL}";
            echo;
        fi;
        return "${retval}";
    fi;
    return 0
}
exeinto () 
{ 
    if [ "$1" == "/" ]; then
        export EXEDESTTREE="";
    else
        export EXEDESTTREE="$1";
        if [ ! -d "${D}${EXEDESTTREE}" ]; then
            install -d "${D}${EXEDESTTREE}";
        fi;
    fi
}
exeopts () 
{ 
    EXEOPTIONS="";
    for x in $*;
    do
        if has nostrip $FEATURES $RESTRICT && [ "$x" == "-s" ]; then
            continue;
        else
            EXEOPTIONS="$EXEOPTIONS $x";
        fi;
    done;
    export EXEOPTIONS
}
filter-flags () 
{ 
    for x in "$@";
    do
        case "${x}" in 
            -fPIC | -fpic | -fPIE | -fpie | -pie)
                etexec-flags
            ;;
            -fstack-protector | -fstack-protector-all)
                fstack-flags
            ;;
            *)

            ;;
        esac;
    done;
    CFLAGS=" ${CFLAGS} ";
    CXXFLAGS=" ${CXXFLAGS} ";
    for x in "$@";
    do
        CFLAGS="${CFLAGS// ${x} / }";
        CXXFLAGS="${CXXFLAGS// ${x} / }";
    done;
    CFLAGS="${CFLAGS:1:${#CFLAGS}-2}";
    CXXFLAGS="${CXXFLAGS:1:${#CXXFLAGS}-2}";
    return 0
}
filter-ldflags () 
{ 
    LDFLAGS=" ${LDFLAGS} ";
    for x in "$@";
    do
        LDFLAGS="${LDFLAGS// ${x} / }";
    done;
    LDFLAGS="${LDFLAGS:1:${#LDFLAGS}-2}";
    return 0
}
filter-lfs-flags () 
{ 
    filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
}
filter-mfpmath () 
{ 
    local orig_mfpmath="`get-flag -mfpmath`";
    local new_math=" `get-flag mfpmath | tr , ' '` ";
    local prune_math="";
    for prune_math in "$@";
    do
        new_math="${new_math/ ${prune_math} / }";
    done;
    new_math="`echo ${new_math:1:${#new_math}-2} | tr ' ' ,`";
    if [ -z "${new_math}" ]; then
        filter-flags ${orig_mfpmath};
    else
        replace-flags ${orig_mfpmath} -mfpmath=${new_math};
    fi;
    return 0
}
fstack-flags () 
{ 
    has_ssp;
    if [ $? == 0 ]; then
        [ -z "`is-flag -yno_propolice`" ] && export CFLAGS="${CFLAGS} `test_flag -fno-stack-protector`";
    fi
}
gen_wrapper () 
{ 
    cat >$1  <<END
#!/bin/sh

$2 "\$@"
END

    chmod 0755 $1
}
get-flag () 
{ 
    local findflag="$1";
    for f in ${CFLAGS} ${CXXFLAGS};
    do
        if [ "${f/${findflag}}" != "${f}" ]; then
            echo "${f/-${findflag}=}";
            return 0;
        fi;
    done;
    return 1
}
get_KV () 
{ 
    local KV="$(< /proc/sys/kernel/osrelease)";
    echo "$(KV_to_int "${KV}")";
    return $?
}
get_bootparam () 
{ 
    local x=;
    local copt=;
    local parms=;
    local retval=1;
    for copt in $(< /proc/cmdline);
    do
        if [ "${copt%=*}" = "gentoo" ]; then
            params="$(gawk -v PARAMS="${copt##*=}" '
				BEGIN { 
					split(PARAMS, nodes, ",")
					for (x in nodes)
						print nodes[x]
				}')";
            for x in ${params};
            do
                if [ "${x}" = "$1" ]; then
                    retval=0;
                fi;
            done;
        fi;
    done;
    return ${retval}
}
get_options () 
{ 
    if [ -f "${svcdir}/options/${myservice}/$1" ]; then
        echo "$(< ${svcdir}/options/${myservice}/$1)";
    fi;
    return 0
}
getcols () 
{ 
    echo "$2"
}
gnuconfig_do_update () 
{ 
    [ $# -eq 0 ] && diefunc "$FUNCNAME" "$LINENO" "$?" "do not call gnuconfig_do_update(); use gnuconfig_update()";
    local configsubs_dir="$(gnuconfig_findnewest)";
    local target targetlist file;
    einfo "Using GNU config files from ${configsubs_dir}";
    for file in "$@";
    do
        if [ ! -r ${configsubs_dir}/${file} ]; then
            eerror "Can't read ${configsubs_dir}/${file}, skipping..";
            continue;
        fi;
        targetlist=`find ${S} -name "${file}"`;
        if [ -n "$targetlist" ]; then
            for target in $targetlist;
            do
                einfo " Updating ${target/$S\//}";
                cp -f ${configsubs_dir}/${file} ${target};
                eend $!;
            done;
        else
            ewarn " No ${file} found in ${S}, skipping..";
        fi;
    done
}
gnuconfig_findnewest () 
{ 
    local locations="/usr/share/gnuconfig/config.sub 	                 /usr/share/automake-1.6/config.sub 	                 /usr/share/automake-1.5/config.sub 	                 /usr/share/automake-1.4/config.sub";
    local lt_location="/usr/share/libtool/config.sub";
    [ -f "${lt_location}" ] && locations="${locations} ${lt_location}";
    grep -s '^timestamp' ${locations} | sort -n -t\' -k2 | tail -n 1 | sed 's,/config.sub:.*$,,'
}
gnuconfig_update () 
{ 
    if [ $# -gt 0 ]; then
        gnuconfig_do_update "$@";
    else
        gnuconfig_do_update config.sub config.guess;
    fi
}
has () 
{ 
    if hasq "$@"; then
        echo "${1}";
        return 0;
    fi;
    return 1
}
has_pic () 
{ 
    [ "${CFLAGS/-fPIC}" != "${CFLAGS}" ] && return 0;
    [ "${CFLAGS/-fpic}" != "${CFLAGS}" ] && return 0;
    has_version sys-devel/hardened-gcc && return 0;
    [ ! -z "`${CC/ .*/} --version| grep pie`" ] && return 0;
    return 1
}
has_pie () 
{ 
    [ "${CFLAGS/-fPIE}" != "${CFLAGS}" ] && return 0;
    [ "${CFLAGS/-fpie}" != "${CFLAGS}" ] && return 0;
    has_version sys-devel/hardened-gcc && return 0;
    [ ! -z "`${CC/ .*/} --version| grep pie`" ] && return 0;
    return 1
}
has_ssp () 
{ 
    [ "${CFLAGS/-fstack-protector}" != "${CFLAGS}" ] && return 0;
    has_version sys-devel/hardened-gcc && return 0;
    [ ! -z "`${CC/ .*/} --version| grep ssp`" ] && return 0;
    return 1
}
has_version () 
{ 
    [ "${EBUILD_PHASE}" == "depend" ] && echo "has_version() in global scope: ${CATEGORY}/$PF" 1>&2;
    if /usr/lib/portage/bin/portageq 'has_version' "${ROOT}" "$1"; then
        return 0;
    else
        return 1;
    fi
}
hasq () 
{ 
    local x;
    local me=$1;
    shift;
    for x in "$@";
    do
        if [ "${x}" == "${me}" ]; then
            return 0;
        fi;
    done;
    return 1
}
inherit () 
{ 
    ECLASS_DEPTH=$(($ECLASS_DEPTH + 1));
    if [[ $ECLASS_DEPTH > 1 ]]; then
        debug-print "*** Multiple Inheritence (Level: ${ECLASS_DEPTH})";
    fi;
    local location;
    local PECLASS;
    while [ "$1" ]; do
        location="${ECLASSDIR}/${1}.eclass";
        PECLASS="$ECLASS";
        export ECLASS="$1";
        if [ -n "$PORTDIR_OVERLAY" ]; then
            local overlay;
            for overlay in ${PORTDIR_OVERLAY};
            do
                olocation="${overlay}/eclass/${1}.eclass";
                if [ -e "$olocation" ]; then
                    location="${olocation}";
                    debug-print "  eclass exists: ${location}";
                    break;
                fi;
            done;
        fi;
        debug-print "inherit: $1 -> $location";
        set -f;
        unset B_DEPEND B_RDEPEND B_CDEPEND B_PDEPEND;
        [ "${DEPEND-unset}" != "unset" ] && B_DEPEND="${DEPEND}";
        [ "${RDEPEND-unset}" != "unset" ] && B_RDEPEND="${RDEPEND}";
        [ "${CDEPEND-unset}" != "unset" ] && B_CDEPEND="${CDEPEND}";
        [ "${PDEPEND-unset}" != "unset" ] && B_PDEPEND="${PDEPEND}";
        unset DEPEND RDEPEND CDEPEND PDEPEND;
        set +f;
        source "$location" || export ERRORMSG="died sourcing $location in inherit()";
        [ -z "${ERRORMSG}" ] || diefunc "$FUNCNAME" "$LINENO" "$?" "${ERRORMSG}";
        set -f;
        [ "${DEPEND-unset}" != "unset" ] && export E_DEPEND="${E_DEPEND} ${DEPEND}";
        [ "${RDEPEND-unset}" != "unset" ] && export E_RDEPEND="${E_RDEPEND} ${RDEPEND}";
        [ "${CDEPEND-unset}" != "unset" ] && export E_CDEPEND="${E_CDEPEND} ${CDEPEND}";
        [ "${PDEPEND-unset}" != "unset" ] && export E_PDEPEND="${E_PDEPEND} ${PDEPEND}";
        [ "${B_DEPEND-unset}" != "unset" ] && DEPEND="${B_DEPEND}";
        [ "${B_DEPEND-unset}" != "unset" ] || unset DEPEND;
        [ "${B_RDEPEND-unset}" != "unset" ] && RDEPEND="${B_RDEPEND}";
        [ "${B_RDEPEND-unset}" != "unset" ] || unset RDEPEND;
        [ "${B_CDEPEND-unset}" != "unset" ] && CDEPEND="${B_CDEPEND}";
        [ "${B_CDEPEND-unset}" != "unset" ] || unset CDEPEND;
        [ "${B_PDEPEND-unset}" != "unset" ] && PDEPEND="${B_PDEPEND}";
        [ "${B_PDEPEND-unset}" != "unset" ] || unset PDEPEND;
        set +f;
        hasq $1 $INHERITED || export INHERITED="$INHERITED $1";
        export ECLASS="$PECLASS";
        shift;
    done;
    ECLASS_DEPTH=$(($ECLASS_DEPTH - 1))
}
init_node () 
{ 
    local DIR=;
    local SUBDIR=;
    local EMPTYDIR=;
    ebegin "Importing local userspace on node";
    try mount -t tmpfs none "${shmdir}";
    for DIR in /etc /var /root;
    do
        if grep -q -v "^${DIR}[[:space:]]" /etc/exports; then
            mount -o nolock -n server:"${DIR}" "${DIR}";
        fi;
        if [ -e "/etc/conf.d/exclude/${DIR}" ]; then
            find "${DIR}/" -type d | grep -v -f "/etc/conf.d/exclude/${DIR}" >"${shmdir}/${DIR}.lst";
        else
            find "${DIR}/" -type d >"${shmdir}/${DIR}.lst";
        fi;
        for SUBDIR in $(< "${shmdir}/${DIR}.lst");
        do
            mkdir -p "${shmdir}/${SUBDIR}";
            chmod --reference="${SUBDIR}" "${shmdir}/${SUBDIR}";
            cp -dp "${SUBDIR}"/* "${shmdir}/${SUBDIR}" >&/dev/null;
        done;
        if [ -e "/etc/conf.d/exclude/${DIR}" ]; then
            for EMPTYDIR in $(< "/etc/conf.d/exclude/${DIR}");
            do
                mkdir -p "${shmdir}/${EMPTYDIR}";
                chmod --reference="${SUBDIR}" "${shmdir}/${SUBDIR}";
            done;
        fi;
        umount -n "${DIR}" >/dev/null;
        mount -n -o bind "${shmdir}/${DIR}" "${DIR}";
    done;
    mkdir -p "${shmdir}/tmp";
    chmod 0777 "${shmdir}/tmp";
    mount -n -o bind "${shmdir}/tmp" /tmp;
    cat /proc/mounts >/etc/mtab;
    cp -f /etc/inittab.node /etc/inittab;
    [ -e /etc/fstab.node ] && cp -f /etc/fstab.node /etc/fstab;
    killall -1 init;
    eend 0;
    return 0
}
insinto () 
{ 
    if [ "$1" == "/" ]; then
        export INSDESTTREE="";
    else
        export INSDESTTREE=$1;
        if [ ! -d "${D}${INSDESTTREE}" ]; then
            install -d "${D}${INSDESTTREE}";
        fi;
    fi
}
insopts () 
{ 
    INSOPTIONS="";
    for x in $*;
    do
        if has nostrip $FEATURES $RESTRICT && [ "$x" == "-s" ]; then
            continue;
        else
            INSOPTIONS="$INSOPTIONS $x";
        fi;
    done;
    export INSOPTIONS
}
into () 
{ 
    if [ $1 == "/" ]; then
        export DESTTREE="";
    else
        export DESTTREE=$1;
        if [ ! -d "${D}${DESTTREE}" ]; then
            install -d "${D}${DESTTREE}";
        fi;
    fi
}
is-flag () 
{ 
    for x in ${CFLAGS} ${CXXFLAGS};
    do
        if [ "${x}" == "$1" ]; then
            echo true;
            return 0;
        fi;
    done;
    return 1
}
keepdir () 
{ 
    dodir "$@";
    local x;
    if [ "$1" == "-R" ] || [ "$1" == "-r" ]; then
        shift;
        find "$@" -type d -printf "${D}/%p/.keep\n" | tr "\n" "\0" | $XARGS -0 -n100 touch || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to recursive create .keep files";
    else
        for x in "$@";
        do
            touch "${D}/${x}/.keep" || diefunc "$FUNCNAME" "$LINENO" "$?" "Failed to create .keep in ${D}/${x}";
        done;
    fi
}
libopts () 
{ 
    LIBOPTIONS="";
    for x in $*;
    do
        if has nostrip $FEATURES $RESTRICT && [ "$x" == "-s" ]; then
            continue;
        else
            LIBOPTIONS="$LIBOPTIONS $x";
        fi;
    done;
    export LIBOPTIONS
}
newcdepend () 
{ 
    debug-print-function newcdepend $*;
    do_newdepend CDEPEND $1
}
newdepend () 
{ 
    debug-print-function newdepend $*;
    debug-print "newdepend: E_DEPEND=$E_DEPEND E_RDEPEND=$E_RDEPEND";
    while [ -n "$1" ]; do
        case $1 in 
            "/autotools")
                do_newdepend DEPEND sys-devel/autoconf sys-devel/automake sys-devel/make
            ;;
            "/c")
                do_newdepend DEPEND sys-devel/gcc virtual/glibc;
                do_newdepend RDEPEND virtual/glibc
            ;;
            *)
                do_newdepend DEPEND $1
            ;;
        esac;
        shift;
    done
}
newpdepend () 
{ 
    debug-print-function newpdepend $*;
    do_newdepend PDEPEND $1
}
newrdepend () 
{ 
    debug-print-function newrdepend $*;
    do_newdepend RDEPEND $1
}
ordertest () 
{ 
    echo "RUNNING FROM EXTRA_FUNCTIONS.SH"
}
pkg_nofetch () 
{ 
    [ -z "${SRC_URI}" ] && return;
    echo "!!! The following are listed in SRC_URI for ${PN}:";
    for MYFILE in `echo ${SRC_URI}`;
    do
        echo "!!!   $MYFILE";
    done
}
pkg_postinst () 
{ 
    return
}
pkg_postrm () 
{ 
    return
}
pkg_preinst () 
{ 
    return
}
pkg_prerm () 
{ 
    return
}
pkg_setup () 
{ 
    return
}
portageq () 
{ 
    [ "${EBUILD_PHASE}" == "depend" ] && echo "portageq in global scope: ${CATEGORY}/$PF" 1>&2;
    /usr/lib/portage/bin/portageq "$@"
}
replace-cpu-flags () 
{ 
    local newcpu="$1";
    shift;
    local oldcpu="";
    for oldcpu in "$@";
    do
        replace-flags -march=${oldcpu} -march=${newcpu};
        replace-flags -mcpu=${oldcpu} -mcpu=${newcpu};
        replace-flags -mtune=${oldcpu} -mtune=${newcpu};
    done;
    return 0
}
replace-flags () 
{ 
    CFLAGS=" ${CFLAGS} ";
    CXXFLAGS=" ${CXXFLAGS} ";
    CFLAGS="${CFLAGS// ${1} / ${2} }";
    CXXFLAGS="${CXXFLAGS// ${1} / ${2} }";
    CFLAGS="${CFLAGS:1:${#CFLAGS}-2}";
    CXXFLAGS="${CXXFLAGS:1:${#CXXFLAGS}-2}";
    return 0
}
replace-sparc64-flags () 
{ 
    local SPARC64_CPUS="ultrasparc v9";
    if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
        for x in ${SPARC64_CPUS};
        do
            CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}";
        done;
    else
        for x in ${SPARC64_CPUS};
        do
            CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}";
        done;
    fi;
    if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
        for x in ${SPARC64_CPUS};
        do
            CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}";
        done;
    else
        for x in ${SPARC64_CPUS};
        do
            CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}";
        done;
    fi
}
save_options () 
{ 
    local myopts="$1";
    shift;
    if [ ! -d "${svcdir}/options/${myservice}" ]; then
        install -d -m0755 "${svcdir}/options/${myservice}";
    fi;
    echo "$*" >"${svcdir}/options/${myservice}/${myopts}";
    return 0
}
setup-allowed-flags () 
{ 
    if [ -z "${ALLOWED_FLAGS}" ]; then
        export ALLOWED_FLAGS="-O -O1 -O2 -mcpu -march -mtune -fstack-protector -pipe -g";
        case "${ARCH}" in 
            mips)
                ALLOWED_FLAGS="${ALLOWED_FLAGS} -mips1 -mips2 -mips3 -mips4 -mabi"
            ;;
            amd64)
                ALLOWED_FLAGS="${ALLOWED_FLAGS} -fPIC"
            ;;
            alpha)
                ALLOWED_FLAGS="${ALLOWED_FLAGS} -fPIC"
            ;;
            ia64)
                ALLOWED_FLAGS="${ALLOWED_FLAGS} -fPIC"
            ;;
        esac;
    fi;
    export UNSTABLE_FLAGS="-Os -O3 -freorder-blocks -fprefetch-loop-arrays";
    return 0
}
src_compile () 
{ 
    is-flag "-march=k6-3" && strip-flags "-fomit-frame-pointer";
    is-flag "-march=k6-2" && strip-flags "-fomit-frame-pointer";
    is-flag "-march=k6" && strip-flags "-fomit-frame-pointer";
    elibtoolize;
    econf --enable-shared || diefunc "$FUNCNAME" "$LINENO" "$?" "configure failed";
    emake || diefunc "$FUNCNAME" "$LINENO" "$?" "make failed"
}
src_install () 
{ 
    dodir /usr/{include/jpeg-mmx,lib};
    make includedir=${D}/usr/include/jpeg-mmx prefix=${D}/usr install || diefunc "$FUNCNAME" "$LINENO" "$?" "install failed";
    mv ${D}/usr/lib/libjpeg.la ${D}/usr/lib/libjpeg-mmx.la;
    mv ${D}/usr/lib/libjpeg.so.62.0.0 ${D}/usr/lib/libjpeg-mmx.so.62.0.0;
    rm ${D}/usr/lib/libjpeg.so;
    ln -s /usr/lib/libjpeg-mmx.so.62.0.0 ${D}/usr/lib/libjpeg-mmx.so;
    rm ${D}/usr/lib/libjpeg.so.62;
    ln -s /usr/lib/libjpeg-mmx.so.62.0.0 ${D}/usr/lib/libjpeg-mmx.so.62;
    dodoc README change.log structure.doc libjpeg.doc
}
src_unpack () 
{ 
    if [ "${A}" != "" ]; then
        unpack ${A};
    fi
}
strip-flags () 
{ 
    setup-allowed-flags;
    local NEW_CFLAGS="";
    local NEW_CXXFLAGS="";
    if [ `has ~${ARCH} ${ACCEPT_KEYWORDS}` ]; then
        [ `use debug` ] && einfo "Enabling the use of some unstable flags";
        ALLOWED_FLAGS="${ALLOWED_FLAGS} ${UNSTABLE_FLAGS}";
    fi;
    set -f;
    for x in ${CFLAGS};
    do
        for y in ${ALLOWED_FLAGS};
        do
            flag=${x%%=*};
            if [ "${flag%%${y}}" = "" ]; then
                NEW_CFLAGS="${NEW_CFLAGS} ${x}";
                break;
            fi;
        done;
    done;
    for x in ${CXXFLAGS};
    do
        for y in ${ALLOWED_FLAGS};
        do
            flag=${x%%=*};
            if [ "${flag%%${y}}" = "" ]; then
                NEW_CXXFLAGS="${NEW_CXXFLAGS} ${x}";
                break;
            fi;
        done;
    done;
    if [ "${CFLAGS/-O}" != "${CFLAGS}" -a "${NEW_CFLAGS/-O}" = "${NEW_CFLAGS}" ]; then
        NEW_CFLAGS="${NEW_CFLAGS} -O2";
    fi;
    if [ "${CXXFLAGS/-O}" != "${CXXFLAGS}" -a "${NEW_CXXFLAGS/-O}" = "${NEW_CXXFLAGS}" ]; then
        NEW_CXXFLAGS="${NEW_CXXFLAGS} -O2";
    fi;
    set +f;
    [ `use debug` ] && einfo "CFLAGS=\"${NEW_CFLAGS}\"" && einfo "CXXFLAGS=\"${NEW_CXXFLAGS}\"";
    export CFLAGS="${NEW_CFLAGS}";
    export CXXFLAGS="${NEW_CXXFLAGS}";
    return 0
}
strip-unsupported-flags () 
{ 
    for x in ${CFLAGS};
    do
        NEW_CFLAGS=${NEW_CFLAGS}" ""`test_flag ${x}`";
    done;
    for x in ${CXXFLAGS};
    do
        NEW_CXXFLAGS=${NEW_CXXFLAGS}" ""`test_flag ${x}`";
    done;
    export CFLAGS="${NEW_CFLAGS}";
    export CXXFLAGS="${NEW_CXXFLAGS}"
}
test_flag () 
{ 
    if [ -z "`gcc -S -xc "$@" -o /dev/null /dev/null 2>&1`" ]; then
        echo "$@";
        return 0;
    fi;
    return 1
}
unpack () 
{ 
    local x;
    local y;
    local myfail;
    local tarvars;
    if [ "$USERLAND" == "BSD" ]; then
        tarvars="";
    else
        tarvars="--no-same-owner";
    fi;
    for x in "$@";
    do
        myfail="failure unpacking ${x}";
        echo ">>> Unpacking ${x} to $(pwd)";
        y="$(echo $x | sed 's:.*\.\(tar\)\.[a-zA-Z0-9]*:\1:')";
        case "${x##*.}" in 
            tar)
                tar ${tarvars} -xf "${DISTDIR}/${x}" || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail"
            ;;
            tgz)
                tar ${tarvars} -xzf "${DISTDIR}/${x}" || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail"
            ;;
            tbz2)
                bzip2 -dc "${DISTDIR}/${x}" | tar ${tarvars} -xf - || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail"
            ;;
            ZIP | zip)
                unzip -qo "${DISTDIR}/${x}" || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail"
            ;;
            gz | Z | z)
                if [ "${y}" == "tar" ]; then
                    tar ${tarvars} -xzf "${DISTDIR}/${x}" || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail";
                else
                    gzip -dc "${DISTDIR}/${x}" >${x%.*} || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail";
                fi
            ;;
            bz2)
                if [ "${y}" == "tar" ]; then
                    bzip2 -dc "${DISTDIR}/${x}" | tar ${tarvars} -xf - || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail";
                else
                    bzip2 -dc "${DISTDIR}/${x}" >${x%.*} || diefunc "$FUNCNAME" "$LINENO" "$?" "$myfail";
                fi
            ;;
            *)
                echo "unpack ${x}: file format not recognized. Ignoring."
            ;;
        esac;
    done
}
use () 
{ 
    if useq ${1}; then
        echo "${1}";
        return 0;
    fi;
    return 1
}
use_enable () 
{ 
    if [ -z "$1" ]; then
        echo "!!! use_enable() called without a parameter." 1>&2;
        echo "!!! use_enable <USEFLAG> [<flagname> [value]]" 1>&2;
        return;
    fi;
    local UE_SUFFIX="";
    if [ ! -z "${3}" ]; then
        UE_SUFFIX="=${3}";
    fi;
    local UWORD="$2";
    if [ -z "${UWORD}" ]; then
        UWORD="$1";
    fi;
    if useq $1; then
        echo "--enable-${UWORD}${UE_SUFFIX}";
        return 0;
    else
        echo "--disable-${UWORD}";
        return 1;
    fi
}
use_with () 
{ 
    if [ -z "$1" ]; then
        echo "!!! use_with() called without a parameter." 1>&2;
        echo "!!! use_with <USEFLAG> [<flagname> [value]]" 1>&2;
        return;
    fi;
    local UW_SUFFIX="";
    if [ ! -z "${3}" ]; then
        UW_SUFFIX="=${3}";
    fi;
    local UWORD="$2";
    if [ -z "${UWORD}" ]; then
        UWORD="$1";
    fi;
    if useq $1; then
        echo "--with-${UWORD}${UW_SUFFIX}";
        return 0;
    else
        echo "--without-${UWORD}";
        return 1;
    fi
}
useq () 
{ 
    local u="${1}";
    local neg=0;
    if [ "${u:0:1}" == "!" ]; then
        u="${u:1}";
        neg=1;
    fi;
    local x;
    for x in ${USE};
    do
        if [ "${x}" == "${u}" ]; then
            if [ ${neg} -eq 1 ]; then
                return 1;
            else
                return 0;
            fi;
        fi;
    done;
    if [ ${neg} -eq 1 ]; then
        return 0;
    else
        return 1;
    fi
}
wrap_rcscript () 
{ 
    local retval=1;
    local myservice="${1##*/}";
    ( echo "function test_script() {";
    cat "$1";
    echo "}" ) >"${svcdir}/${myservice}-$$";
    if source "${svcdir}/${myservice}-$$" >&/dev/null; then
        test_script >&/dev/null;
        retval=0;
    fi;
    rm -f "${svcdir}/${myservice}-$$";
    return "${retval}"
}

************************ Denotes a break between files produced during compile
************************ The name of the file after this break is
************************ jpapimin.out

// /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/cc1 -quiet -I. -iprefix /usr/bin/../../../lib/gcc-lib/i686-pc-linux-gnu/3.3.3/ -D__GNUC__=3 -D__GNUC_MINOR__=3 -D__GNUC_PATCHLEVEL__=3 -DPIC ./jdapimin.c -quiet -dumpbase jdapimin.c -march=pentium3 -auxbase jdapimin -O2 -fomit-frame-pointer -fPIC -o -
# 1 "jdapimin.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "jdapimin.c"
# 20 "jdapimin.c"
# 1 "jinclude.h" 1
# 20 "jinclude.h"
# 1 "jconfig.h" 1
# 21 "jinclude.h" 2
# 35 "jinclude.h"
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 151 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 213 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 3 4
typedef unsigned int size_t;
# 325 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 3 4
typedef long int wchar_t;
# 36 "jinclude.h" 2



# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 295 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 296 "/usr/include/features.h" 2 3 4
# 318 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 319 "/usr/include/features.h" 2 3 4
# 26 "/usr/include/stdlib.h" 2 3 4







# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4


# 93 "/usr/include/stdlib.h" 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;



# 137 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) ;




extern double atof (__const char *__nptr) __attribute__ ((__pure__));

extern int atoi (__const char *__nptr) __attribute__ ((__pure__));

extern long int atol (__const char *__nptr) __attribute__ ((__pure__));





__extension__ extern long long int atoll (__const char *__nptr)
     __attribute__ ((__pure__));





extern double strtod (__const char *__restrict __nptr,
                      char **__restrict __endptr) ;

# 174 "/usr/include/stdlib.h" 3 4


extern long int strtol (__const char *__restrict __nptr,
                        char **__restrict __endptr, int __base) ;

extern unsigned long int strtoul (__const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
     ;




__extension__
extern long long int strtoq (__const char *__restrict __nptr,
                             char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
     ;





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
                              char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
     ;

# 264 "/usr/include/stdlib.h" 3 4
extern double __strtod_internal (__const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
     ;
extern float __strtof_internal (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
     ;
extern long double __strtold_internal (__const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) ;

extern long int __strtol_internal (__const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group) ;



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group) ;




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) ;



__extension__
extern unsigned long long int __strtoull_internal (__const char *
                                                   __restrict __nptr,
                                                   char **__restrict __endptr,
                                                   int __base, int __group)
     ;








extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}

# 343 "/usr/include/stdlib.h" 3 4
__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




extern __inline double
atof (__const char *__nptr)
{
  return strtod (__nptr, (char **) ((void *)0));
}
extern __inline int
atoi (__const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void *)0), 10);
}
extern __inline long int
atol (__const char *__nptr)
{
  return strtol (__nptr, (char **) ((void *)0), 10);
}




__extension__ extern __inline long long int
atoll (__const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void *)0), 10);
}

# 408 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) ;


extern long int a64l (__const char *__s) __attribute__ ((__pure__));




# 1 "/usr/include/sys/types.h" 1 3 4
# 29 "/usr/include/sys/types.h" 3 4


# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;




__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef unsigned long long int __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long long int __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef long long int __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef unsigned long long int __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef long long int __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef unsigned long long int __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef unsigned long long int __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 32 "/usr/include/sys/types.h" 2 3 4



typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;



typedef __ino_t ino_t;
# 62 "/usr/include/sys/types.h" 3 4
typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;





typedef __off_t off_t;
# 100 "/usr/include/sys/types.h" 3 4
typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 133 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 74 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 134 "/usr/include/sys/types.h" 2 3 4
# 147 "/usr/include/sys/types.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 191 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 213 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 214 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;





# 1 "/usr/include/time.h" 1 3 4
# 118 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };
# 45 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4


typedef __suseconds_t suseconds_t;





typedef long int __fd_mask;
# 67 "/usr/include/sys/select.h" 3 4
typedef struct
  {






    __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))];


  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4

# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
                   fd_set *__restrict __writefds,
                   fd_set *__restrict __exceptfds,
                   struct timeval *__restrict __timeout);
# 128 "/usr/include/sys/select.h" 3 4

# 217 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     ;
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     ;
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
                                                        unsigned int __minor)
     ;


__extension__ extern __inline unsigned int
gnu_dev_major (unsigned long long int __dev)
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
gnu_dev_minor (unsigned long long int __dev)
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor)
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
          | (((unsigned long long int) (__minor & ~0xff)) << 12)
          | (((unsigned long long int) (__major & ~0xfff)) << 32));
}
# 220 "/usr/include/sys/types.h" 2 3 4
# 231 "/usr/include/sys/types.h" 3 4
typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 266 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 83 "/usr/include/bits/sched.h" 3 4
struct __sched_param
  {
    int __sched_priority;
  };
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;

};



typedef struct _pthread_descr_struct *_pthread_descr;





typedef struct __pthread_attr_s
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;





__extension__ typedef long long __pthread_cond_align_t;




typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
  char __padding[48 - sizeof (struct _pthread_fastlock)
                 - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
  __pthread_cond_align_t __align;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;
# 150 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;
# 267 "/usr/include/sys/types.h" 2 3 4



# 417 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) ;


extern void srandom (unsigned int __seed) ;





extern char *initstate (unsigned int __seed, char *__statebuf,
                        size_t __statelen) ;



extern char *setstate (char *__statebuf) ;







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
                     int32_t *__restrict __result) ;

extern int srandom_r (unsigned int __seed, struct random_data *__buf) ;

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf) ;

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf) ;






extern int rand (void) ;

extern void srand (unsigned int __seed) ;




extern int rand_r (unsigned int *__seed) ;







extern double drand48 (void) ;
extern double erand48 (unsigned short int __xsubi[3]) ;


extern long int lrand48 (void) ;
extern long int nrand48 (unsigned short int __xsubi[3]) ;


extern long int mrand48 (void) ;
extern long int jrand48 (unsigned short int __xsubi[3]) ;


extern void srand48 (long int __seedval) ;
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) ;
extern void lcong48 (unsigned short int __param[7]) ;





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     ;

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) ;

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer) ;









extern void *malloc (size_t __size) __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
     __attribute__ ((__malloc__));







extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__malloc__));

extern void free (void *__ptr) ;




extern void cfree (void *__ptr) ;



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4







extern void *alloca (size_t __size) ;






# 579 "/usr/include/stdlib.h" 2 3 4




extern void *valloc (size_t __size) __attribute__ ((__malloc__));
# 592 "/usr/include/stdlib.h" 3 4


extern void abort (void) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) ;





extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     ;






extern void exit (int __status) __attribute__ ((__noreturn__));

# 624 "/usr/include/stdlib.h" 3 4


extern char *getenv (__const char *__name) ;




extern char *__secure_getenv (__const char *__name) ;





extern int putenv (char *__string) ;





extern int setenv (__const char *__name, __const char *__value, int __replace)
     ;


extern int unsetenv (__const char *__name) ;






extern int clearenv (void) ;
# 663 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) ;
# 674 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template);
# 693 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) ;








extern int system (__const char *__command);

# 720 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name,
                       char *__restrict __resolved) ;






typedef int (*__compar_fn_t) (__const void *, __const void *);









extern void *bsearch (__const void *__key, __const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar);



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar);



extern int abs (int __x) __attribute__ ((__const__));
extern long int labs (long int __x) __attribute__ ((__const__));












extern div_t div (int __numer, int __denom)
     __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     __attribute__ ((__const__));

# 784 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *gcvt (double __value, int __ndigit, char *__buf) ;




extern char *qecvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qfcvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf) ;




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;







extern int mblen (__const char *__s, size_t __n) ;


extern int mbtowc (wchar_t *__restrict __pwc,
                   __const char *__restrict __s, size_t __n) ;


extern int wctomb (char *__s, wchar_t __wchar) ;



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
                        __const char *__restrict __s, size_t __n) ;

extern size_t wcstombs (char *__restrict __s,
                        __const wchar_t *__restrict __pwcs, size_t __n)
     ;








extern int rpmatch (__const char *__response) ;
# 916 "/usr/include/stdlib.h" 3 4
extern int getloadavg (double __loadavg[], int __nelem) ;






# 40 "jinclude.h" 2






# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 44 "/usr/include/stdio.h" 3 4


typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 354 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 24 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3 4

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/gconv.h" 1 3 4
# 28 "/usr/include/gconv.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 29 "/usr/include/gconv.h" 2 3 4


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 163 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 173 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 196 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 264 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 312 "/usr/include/libio.h" 3 4
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 351 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);
# 403 "/usr/include/libio.h" 3 4
extern int __underflow (_IO_FILE *) ;
extern int __uflow (_IO_FILE *) ;
extern int __overflow (_IO_FILE *, int) ;
extern wint_t __wunderflow (_IO_FILE *) ;
extern wint_t __wuflow (_IO_FILE *) ;
extern wint_t __woverflow (_IO_FILE *, wint_t) ;
# 433 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp) ;
extern int _IO_putc (int __c, _IO_FILE *__fp) ;
extern int _IO_feof (_IO_FILE *__fp) ;
extern int _IO_ferror (_IO_FILE *__fp) ;

extern int _IO_peekc_locked (_IO_FILE *__fp) ;





extern void _IO_flockfile (_IO_FILE *) ;
extern void _IO_funlockfile (_IO_FILE *) ;
extern int _IO_ftrylockfile (_IO_FILE *) ;
# 463 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) ;
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) ;
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) ;
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) ;

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) ;
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) ;

extern void _IO_free_backup_area (_IO_FILE *) ;
# 73 "/usr/include/stdio.h" 2 3 4
# 86 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;




# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (__const char *__filename) ;

extern int rename (__const char *__old, __const char *__new) ;









extern FILE *tmpfile (void);
# 178 "/usr/include/stdio.h" 3 4
extern char *tmpnam (char *__s) ;





extern char *tmpnam_r (char *__s) ;
# 196 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 221 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 235 "/usr/include/stdio.h" 3 4






extern FILE *fopen (__const char *__restrict __filename,
                    __const char *__restrict __modes);




extern FILE *freopen (__const char *__restrict __filename,
                      __const char *__restrict __modes,
                      FILE *__restrict __stream);
# 262 "/usr/include/stdio.h" 3 4

# 273 "/usr/include/stdio.h" 3 4
extern FILE *fdopen (int __fd, __const char *__modes) ;
# 294 "/usr/include/stdio.h" 3 4



extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) ;



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) ;





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) ;


extern void setlinebuf (FILE *__stream) ;








extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) ;





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) ;





extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
     __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 3, 0)));

# 388 "/usr/include/stdio.h" 3 4





extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) ;

# 430 "/usr/include/stdio.h" 3 4





extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 454 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 578 "/usr/include/stdio.h" 3 4





extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s);

# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 686 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 709 "/usr/include/stdio.h" 3 4

# 718 "/usr/include/stdio.h" 3 4


extern void clearerr (FILE *__stream) ;

extern int feof (FILE *__stream) ;

extern int ferror (FILE *__stream) ;




extern void clearerr_unlocked (FILE *__stream) ;
extern int feof_unlocked (FILE *__stream) ;
extern int ferror_unlocked (FILE *__stream) ;








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) ;




extern int fileno_unlocked (FILE *__stream) ;
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) ;
# 807 "/usr/include/stdio.h" 3 4
extern void flockfile (FILE *__stream) ;



extern int ftrylockfile (FILE *__stream) ;


extern void funlockfile (FILE *__stream) ;
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 33 "/usr/include/bits/stdio.h" 3 4
extern __inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline int
getc_unlocked (FILE *__fp)
{
  return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline int
getchar_unlocked (void)
{
  return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline int
putchar_unlocked (int __c)
{
  return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
# 111 "/usr/include/bits/stdio.h" 3 4
extern __inline int
feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 829 "/usr/include/stdio.h" 2 3 4



# 47 "jinclude.h" 2
# 66 "jinclude.h"
# 1 "/usr/include/string.h" 1 3 4
# 28 "/usr/include/string.h" 3 4





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.3/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) ;


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     ;






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
     ;





extern void *memset (void *__s, int __c, size_t __n) ;


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
      __attribute__ ((__pure__));

# 80 "/usr/include/string.h" 3 4


extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     ;

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) ;


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     ;

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) ;


extern int strcmp (__const char *__s1, __const char *__s2)
     __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
     __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) ;

# 126 "/usr/include/string.h" 3 4
extern char *strdup (__const char *__s) __attribute__ ((__malloc__));
# 160 "/usr/include/string.h" 3 4


extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) __attribute__ ((__pure__));











extern size_t strcspn (__const char *__s, __const char *__reject)
     __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
     __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
     __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
     __attribute__ ((__pure__));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     ;




extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) ;

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) ;
# 228 "/usr/include/string.h" 3 4


extern size_t strlen (__const char *__s) __attribute__ ((__pure__));

# 241 "/usr/include/string.h" 3 4


extern char *strerror (int __errnum) ;




extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) ;




extern void __bzero (void *__s, size_t __n) ;



extern void bcopy (__const void *__src, void *__dest, size_t __n) ;


extern void bzero (void *__s, size_t __n) ;


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) __attribute__ ((__pure__));



extern int ffs (int __i) __attribute__ ((__const__));
# 287 "/usr/include/string.h" 3 4
extern int strcasecmp (__const char *__s1, __const char *__s2)
     __attribute__ ((__pure__));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     __attribute__ ((__pure__));
# 309 "/usr/include/string.h" 3 4
extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) ;
# 372 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string.h" 1 3 4
# 373 "/usr/include/string.h" 2 3 4


# 1 "/usr/include/bits/string2.h" 1 3 4
# 389 "/usr/include/bits/string2.h" 3 4
extern void *__rawmemchr (const void *__s, int __c);
# 919 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strcspn_c1 (__const char *__s, int __reject);
extern __inline size_t
__strcspn_c1 (__const char *__s, int __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (__const char *__s, int __reject1,
                                     int __reject2);
extern __inline size_t
__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (__const char *__s, int __reject1,
                                     int __reject2, int __reject3);
extern __inline size_t
__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
              int __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 976 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strspn_c1 (__const char *__s, int __accept);
extern __inline size_t
__strspn_c1 (__const char *__s, int __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (__const char *__s, int __accept1,
                                    int __accept2);
extern __inline size_t
__strspn_c2 (__const char *__s, int __accept1, int __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
                                    int __accept2, int __accept3);
extern __inline size_t
__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
         || __s[__result] == __accept3)
    ++__result;
  return __result;
}
# 1033 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
                                     int __accept2);
extern __inline char *
__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
                                     int __accept2, int __accept3);
extern __inline char *
__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
              int __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
         && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1085 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  __result = ((void *)0);
  if (*__s != '\0')
    {
      __result = __s++;
      while (*__s != '\0')
        if (*__s++ == __sep)
          {
            __s[-1] = '\0';
            break;
          }
      *__nextp = __s;
    }
  return __result;
}
# 1117 "/usr/include/bits/string2.h" 3 4
extern char *__strsep_g (char **__stringp, __const char *__delim);
# 1135 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : strchr (__retval, __reject)))) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
        {
          if (*__cp == '\0')
            {
              __cp = ((void *)0);
          break;
            }
          if (*__cp == __reject1 || *__cp == __reject2)
            {
              *__cp++ = '\0';
              break;
            }
          ++__cp;
        }
      *__s = __cp;
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
                                   char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
        {
          if (*__cp == '\0')
            {
              __cp = ((void *)0);
          break;
            }
          if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
            {
              *__cp++ = '\0';
              break;
            }
          ++__cp;
        }
      *__s = __cp;
    }
  return __retval;
}
# 1216 "/usr/include/bits/string2.h" 3 4
extern char *__strdup (__const char *__string) __attribute__ ((__malloc__));
# 1235 "/usr/include/bits/string2.h" 3 4
extern char *__strndup (__const char *__string, size_t __n)
     __attribute__ ((__malloc__));
# 376 "/usr/include/string.h" 2 3 4




# 67 "jinclude.h" 2
# 21 "jdapimin.c" 2
# 1 "jpeglib.h" 1
# 26 "jpeglib.h"
# 1 "jmorecfg.h" 1
# 59 "jmorecfg.h"
typedef unsigned char JSAMPLE;
# 99 "jmorecfg.h"
typedef short JCOEF;
# 120 "jmorecfg.h"
typedef unsigned char JOCTET;
# 145 "jmorecfg.h"
typedef unsigned char UINT8;
# 157 "jmorecfg.h"
typedef unsigned short UINT16;







typedef short INT16;





typedef long INT32;
# 181 "jmorecfg.h"
typedef unsigned int JDIMENSION;
# 237 "jmorecfg.h"
typedef int boolean;
# 27 "jpeglib.h" 2





        extern int MMXAvailable;
# 72 "jpeglib.h"
typedef JSAMPLE *JSAMPROW;
typedef JSAMPROW *JSAMPARRAY;
typedef JSAMPARRAY *JSAMPIMAGE;

typedef JCOEF JBLOCK[64];
typedef JBLOCK *JBLOCKROW;
typedef JBLOCKROW *JBLOCKARRAY;
typedef JBLOCKARRAY *JBLOCKIMAGE;

typedef JCOEF *JCOEFPTR;







typedef struct {




  UINT16 quantval[64];





  boolean sent_table;
} JQUANT_TBL;




typedef struct {

  UINT8 bits[17];

  UINT8 huffval[256];





  boolean sent_table;
} JHUFF_TBL;




typedef struct {



  int component_id;
  int component_index;
  int h_samp_factor;
  int v_samp_factor;
  int quant_tbl_no;




  int dc_tbl_no;
  int ac_tbl_no;
# 145 "jpeglib.h"
  JDIMENSION width_in_blocks;
  JDIMENSION height_in_blocks;






  int DCT_scaled_size;






  JDIMENSION downsampled_width;
  JDIMENSION downsampled_height;




  boolean component_needed;



  int MCU_width;
  int MCU_height;
  int MCU_blocks;
  int MCU_sample_width;
  int last_col_width;
  int last_row_height;





  JQUANT_TBL * quant_table;


  void * dct_table;
} jpeg_component_info;




typedef struct {
  int comps_in_scan;
  int component_index[4];
  int Ss, Se;
  int Ah, Al;
} jpeg_scan_info;



typedef struct jpeg_marker_struct * jpeg_saved_marker_ptr;

struct jpeg_marker_struct {
  jpeg_saved_marker_ptr next;
  UINT8 marker;
  unsigned int original_length;
  unsigned int data_length;
  JOCTET * data;

};



typedef enum {
        JCS_UNKNOWN,
        JCS_GRAYSCALE,
        JCS_RGB,
        JCS_YCbCr,
        JCS_CMYK,
        JCS_YCCK
} J_COLOR_SPACE;



typedef enum {
        JDCT_ISLOW,
        JDCT_IFAST,
        JDCT_FLOAT
} J_DCT_METHOD;
# 238 "jpeglib.h"
typedef enum {
        JDITHER_NONE,
        JDITHER_ORDERED,
        JDITHER_FS
} J_DITHER_MODE;
# 259 "jpeglib.h"
struct jpeg_common_struct {
  struct jpeg_error_mgr * err; struct jpeg_memory_mgr * mem; struct jpeg_progress_mgr * progress; void * client_data; boolean is_decompressor; int global_state;




};

typedef struct jpeg_common_struct * j_common_ptr;
typedef struct jpeg_compress_struct * j_compress_ptr;
typedef struct jpeg_decompress_struct * j_decompress_ptr;




struct jpeg_compress_struct {
  struct jpeg_error_mgr * err; struct jpeg_memory_mgr * mem; struct jpeg_progress_mgr * progress; void * client_data; boolean is_decompressor; int global_state;


  struct jpeg_destination_mgr * dest;






  JDIMENSION image_width;
  JDIMENSION image_height;
  int input_components;
  J_COLOR_SPACE in_color_space;

  double input_gamma;
# 300 "jpeglib.h"
  int data_precision;

  int num_components;
  J_COLOR_SPACE jpeg_color_space;

  jpeg_component_info * comp_info;


  JQUANT_TBL * quant_tbl_ptrs[4];


  JHUFF_TBL * dc_huff_tbl_ptrs[4];
  JHUFF_TBL * ac_huff_tbl_ptrs[4];


  UINT8 arith_dc_L[16];
  UINT8 arith_dc_U[16];
  UINT8 arith_ac_K[16];

  int num_scans;
  const jpeg_scan_info * scan_info;





  boolean raw_data_in;
  boolean arith_code;
  boolean optimize_coding;
  boolean CCIR601_sampling;
  int smoothing_factor;
  J_DCT_METHOD dct_method;






  unsigned int restart_interval;
  int restart_in_rows;



  boolean write_JFIF_header;
  UINT8 JFIF_major_version;
  UINT8 JFIF_minor_version;




  UINT8 density_unit;
  UINT16 X_density;
  UINT16 Y_density;
  boolean write_Adobe_marker;






  JDIMENSION next_scanline;
# 369 "jpeglib.h"
  boolean progressive_mode;
  int max_h_samp_factor;
  int max_v_samp_factor;

  JDIMENSION total_iMCU_rows;
# 384 "jpeglib.h"
  int comps_in_scan;
  jpeg_component_info * cur_comp_info[4];


  JDIMENSION MCUs_per_row;
  JDIMENSION MCU_rows_in_scan;

  int blocks_in_MCU;
  int MCU_membership[10];



  int Ss, Se, Ah, Al;




  struct jpeg_comp_master * master;
  struct jpeg_c_main_controller * main;
  struct jpeg_c_prep_controller * prep;
  struct jpeg_c_coef_controller * coef;
  struct jpeg_marker_writer * marker;
  struct jpeg_color_converter * cconvert;
  struct jpeg_downsampler * downsample;
  struct jpeg_forward_dct * fdct;
  struct jpeg_entropy_encoder * entropy;
  jpeg_scan_info * script_space;
  int script_space_size;
};




struct jpeg_decompress_struct {
  struct jpeg_error_mgr * err; struct jpeg_memory_mgr * mem; struct jpeg_progress_mgr * progress; void * client_data; boolean is_decompressor; int global_state;


  struct jpeg_source_mgr * src;




  JDIMENSION image_width;
  JDIMENSION image_height;
  int num_components;
  J_COLOR_SPACE jpeg_color_space;






  J_COLOR_SPACE out_color_space;

  unsigned int scale_num, scale_denom;

  double output_gamma;

  boolean buffered_image;
  boolean raw_data_out;

  J_DCT_METHOD dct_method;
  boolean do_fancy_upsampling;
  boolean do_block_smoothing;

  boolean quantize_colors;

  J_DITHER_MODE dither_mode;
  boolean two_pass_quantize;
  int desired_number_of_colors;

  boolean enable_1pass_quant;
  boolean enable_external_quant;
  boolean enable_2pass_quant;







  JDIMENSION output_width;
  JDIMENSION output_height;
  int out_color_components;
  int output_components;



  int rec_outbuf_height;
# 484 "jpeglib.h"
  int actual_number_of_colors;
  JSAMPARRAY colormap;
# 495 "jpeglib.h"
  JDIMENSION output_scanline;




  int input_scan_number;
  JDIMENSION input_iMCU_row;





  int output_scan_number;
  JDIMENSION output_iMCU_row;
# 517 "jpeglib.h"
  int (*coef_bits)[64];
# 528 "jpeglib.h"
  JQUANT_TBL * quant_tbl_ptrs[4];


  JHUFF_TBL * dc_huff_tbl_ptrs[4];
  JHUFF_TBL * ac_huff_tbl_ptrs[4];






  int data_precision;

  jpeg_component_info * comp_info;


  boolean progressive_mode;
  boolean arith_code;

  UINT8 arith_dc_L[16];
  UINT8 arith_dc_U[16];
  UINT8 arith_ac_K[16];

  unsigned int restart_interval;




  boolean saw_JFIF_marker;

  UINT8 JFIF_major_version;
  UINT8 JFIF_minor_version;
  UINT8 density_unit;
  UINT16 X_density;
  UINT16 Y_density;
  boolean saw_Adobe_marker;
  UINT8 Adobe_transform;

  boolean CCIR601_sampling;





  jpeg_saved_marker_ptr marker_list;
# 581 "jpeglib.h"
  int max_h_samp_factor;
  int max_v_samp_factor;

  int min_DCT_scaled_size;

  JDIMENSION total_iMCU_rows;
# 595 "jpeglib.h"
  JSAMPLE * sample_range_limit;






  int comps_in_scan;
  jpeg_component_info * cur_comp_info[4];


  JDIMENSION MCUs_per_row;
  JDIMENSION MCU_rows_in_scan;

  int blocks_in_MCU;
  int MCU_membership[10];



  int Ss, Se, Ah, Al;





  int unread_marker;




  struct jpeg_decomp_master * master;
  struct jpeg_d_main_controller * main;
  struct jpeg_d_coef_controller * coef;
  struct jpeg_d_post_controller * post;
  struct jpeg_input_controller * inputctl;
  struct jpeg_marker_reader * marker;
  struct jpeg_entropy_decoder * entropy;
  struct jpeg_inverse_dct * idct;
  struct jpeg_upsampler * upsample;
  struct jpeg_color_deconverter * cconvert;
  struct jpeg_color_quantizer * cquantize;
};
# 649 "jpeglib.h"
struct jpeg_error_mgr {

  void (*error_exit) (j_common_ptr cinfo);

  void (*emit_message) (j_common_ptr cinfo, int msg_level);

  void (*output_message) (j_common_ptr cinfo);

  void (*format_message) (j_common_ptr cinfo, char * buffer);


  void (*reset_error_mgr) (j_common_ptr cinfo);




  int msg_code;

  union {
    int i[8];
    char s[80];
  } msg_parm;



  int trace_level;







  long num_warnings;
# 694 "jpeglib.h"
  const char * const * jpeg_message_table;
  int last_jpeg_message;



  const char * const * addon_message_table;
  int first_addon_message;
  int last_addon_message;
};




struct jpeg_progress_mgr {
  void (*progress_monitor) (j_common_ptr cinfo);

  long pass_counter;
  long pass_limit;
  int completed_passes;
  int total_passes;
};




struct jpeg_destination_mgr {
  JOCTET * next_output_byte;
  size_t free_in_buffer;

  void (*init_destination) (j_compress_ptr cinfo);
  boolean (*empty_output_buffer) (j_compress_ptr cinfo);
  void (*term_destination) (j_compress_ptr cinfo);
};




struct jpeg_source_mgr {
  const JOCTET * next_input_byte;
  size_t bytes_in_buffer;

  void (*init_source) (j_decompress_ptr cinfo);
  boolean (*fill_input_buffer) (j_decompress_ptr cinfo);
  void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
  boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
  void (*term_source) (j_decompress_ptr cinfo);
};
# 758 "jpeglib.h"
typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
typedef struct jvirt_barray_control * jvirt_barray_ptr;


struct jpeg_memory_mgr {

  void * (*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);

  void * (*alloc_large) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);

  JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows);


  JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows);


  jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION samplesperrow, JDIMENSION numrows, JDIMENSION maxaccess);





  jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess);





  void (*realize_virt_arrays) (j_common_ptr cinfo);
  JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable);




  JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable);




  void (*free_pool) (j_common_ptr cinfo, int pool_id);
  void (*self_destruct) (j_common_ptr cinfo);






  long max_memory_to_use;


  long max_alloc_chunk;
};





typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo);
# 890 "jpeglib.h"
extern struct jpeg_error_mgr * jpeg_std_error
        (struct jpeg_error_mgr * err);
# 906 "jpeglib.h"
extern void jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize);

extern void jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize);


extern void jpeg_destroy_compress (j_compress_ptr cinfo);
extern void jpeg_destroy_decompress (j_decompress_ptr cinfo);



extern void jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile);
extern void jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile);


extern void jpeg_set_defaults (j_compress_ptr cinfo);

extern void jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace);

extern void jpeg_default_colorspace (j_compress_ptr cinfo);
extern void jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline);

extern void jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor, boolean force_baseline);


extern void jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline);



extern int jpeg_quality_scaling (int quality);
extern void jpeg_simple_progression (j_compress_ptr cinfo);
extern void jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress);

extern JQUANT_TBL * jpeg_alloc_quant_table (j_common_ptr cinfo);
extern JHUFF_TBL * jpeg_alloc_huff_table (j_common_ptr cinfo);


extern void jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables);

extern JDIMENSION jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines);


extern void jpeg_finish_compress (j_compress_ptr cinfo);


extern JDIMENSION jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data, JDIMENSION num_lines);




extern void jpeg_write_marker
        (j_compress_ptr cinfo, int marker, const JOCTET * dataptr, unsigned int datalen);


extern void jpeg_write_m_header
        (j_compress_ptr cinfo, int marker, unsigned int datalen);
extern void jpeg_write_m_byte
        (j_compress_ptr cinfo, int val);


extern void jpeg_write_tables (j_compress_ptr cinfo);


extern int jpeg_read_header (j_decompress_ptr cinfo, boolean require_image);
# 981 "jpeglib.h"
extern boolean jpeg_start_decompress (j_decompress_ptr cinfo);
extern JDIMENSION jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines);


extern boolean jpeg_finish_decompress (j_decompress_ptr cinfo);


extern JDIMENSION jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data, JDIMENSION max_lines);




extern boolean jpeg_has_multiple_scans (j_decompress_ptr cinfo);
extern boolean jpeg_start_output (j_decompress_ptr cinfo, int scan_number);

extern boolean jpeg_finish_output (j_decompress_ptr cinfo);
extern boolean jpeg_input_complete (j_decompress_ptr cinfo);
extern void jpeg_new_colormap (j_decompress_ptr cinfo);
extern int jpeg_consume_input (j_decompress_ptr cinfo);
# 1008 "jpeglib.h"
extern void jpeg_calc_output_dimensions (j_decompress_ptr cinfo);


extern void jpeg_save_markers
        (j_decompress_ptr cinfo, int marker_code, unsigned int length_limit);



extern void jpeg_set_marker_processor
        (j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine);



extern jvirt_barray_ptr * jpeg_read_coefficients (j_decompress_ptr cinfo);
extern void jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays);

extern void jpeg_copy_critical_parameters (j_decompress_ptr srcinfo, j_compress_ptr dstinfo);
# 1033 "jpeglib.h"
extern void jpeg_abort_compress (j_compress_ptr cinfo);
extern void jpeg_abort_decompress (j_decompress_ptr cinfo);




extern void jpeg_abort (j_common_ptr cinfo);
extern void jpeg_destroy (j_common_ptr cinfo);


extern boolean jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired);
# 1098 "jpeglib.h"
# 1 "jpegint.h" 1
# 16 "jpegint.h"
typedef enum {
        JBUF_PASS_THRU,

        JBUF_SAVE_SOURCE,
        JBUF_CRANK_DEST,
        JBUF_SAVE_AND_PASS
} J_BUF_MODE;
# 45 "jpegint.h"
struct jpeg_comp_master {
  void (*prepare_for_pass) (j_compress_ptr cinfo);
  void (*pass_startup) (j_compress_ptr cinfo);
  void (*finish_pass) (j_compress_ptr cinfo);


  boolean call_pass_startup;
  boolean is_last_pass;
};


struct jpeg_c_main_controller {
  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
  void (*process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail);


};


struct jpeg_c_prep_controller {
  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
  void (*pre_process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail, JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, JDIMENSION out_row_groups_avail);






};


struct jpeg_c_coef_controller {
  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
  boolean (*compress_data) (j_compress_ptr cinfo, JSAMPIMAGE input_buf);

};


struct jpeg_color_converter {
  void (*start_pass) (j_compress_ptr cinfo);
  void (*color_convert) (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows);


};


struct jpeg_downsampler {
  void (*start_pass) (j_compress_ptr cinfo);
  void (*downsample) (j_compress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_index, JSAMPIMAGE output_buf, JDIMENSION out_row_group_index);




  boolean need_context_rows;
};


struct jpeg_forward_dct {
  void (*start_pass) (j_compress_ptr cinfo);

  void (*forward_DCT) (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks);




};


struct jpeg_entropy_encoder {
  void (*start_pass) (j_compress_ptr cinfo, boolean gather_statistics);
  boolean (*encode_mcu) (j_compress_ptr cinfo, JBLOCKROW *MCU_data);
  void (*finish_pass) (j_compress_ptr cinfo);
};


struct jpeg_marker_writer {
  void (*write_file_header) (j_compress_ptr cinfo);
  void (*write_frame_header) (j_compress_ptr cinfo);
  void (*write_scan_header) (j_compress_ptr cinfo);
  void (*write_file_trailer) (j_compress_ptr cinfo);
  void (*write_tables_only) (j_compress_ptr cinfo);


  void (*write_marker_header) (j_compress_ptr cinfo, int marker, unsigned int datalen);

  void (*write_marker_byte) (j_compress_ptr cinfo, int val);
};





struct jpeg_decomp_master {
  void (*prepare_for_output_pass) (j_decompress_ptr cinfo);
  void (*finish_output_pass) (j_decompress_ptr cinfo);


  boolean is_dummy_pass;
};


struct jpeg_input_controller {
  int (*consume_input) (j_decompress_ptr cinfo);
  void (*reset_input_controller) (j_decompress_ptr cinfo);
  void (*start_input_pass) (j_decompress_ptr cinfo);
  void (*finish_input_pass) (j_decompress_ptr cinfo);


  boolean has_multiple_scans;
  boolean eoi_reached;
};


struct jpeg_d_main_controller {
  void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
  void (*process_data) (j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);


};


struct jpeg_d_coef_controller {
  void (*start_input_pass) (j_decompress_ptr cinfo);
  int (*consume_data) (j_decompress_ptr cinfo);
  void (*start_output_pass) (j_decompress_ptr cinfo);
  int (*decompress_data) (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);


  jvirt_barray_ptr *coef_arrays;
};


struct jpeg_d_post_controller {
  void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
  void (*post_process_data) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);






};


struct jpeg_marker_reader {
  void (*reset_marker_reader) (j_decompress_ptr cinfo);




  int (*read_markers) (j_decompress_ptr cinfo);

  jpeg_marker_parser_method read_restart_marker;




  boolean saw_SOI;
  boolean saw_SOF;
  int next_restart_num;
  unsigned int discarded_bytes;
};


struct jpeg_entropy_decoder {
  void (*start_pass) (j_decompress_ptr cinfo);
  boolean (*decode_mcu) (j_decompress_ptr cinfo, JBLOCKROW *MCU_data);




  boolean insufficient_data;
};


typedef void (*inverse_DCT_method_ptr) (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);




struct jpeg_inverse_dct {
  void (*start_pass) (j_decompress_ptr cinfo);

  inverse_DCT_method_ptr inverse_DCT[10];
};


struct jpeg_upsampler {
  void (*start_pass) (j_decompress_ptr cinfo);
  void (*upsample) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);







  boolean need_context_rows;
};


struct jpeg_color_deconverter {
  void (*start_pass) (j_decompress_ptr cinfo);
  void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows);


};


struct jpeg_color_quantizer {
  void (*start_pass) (j_decompress_ptr cinfo, boolean is_pre_scan);
  void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows);


  void (*finish_pass) (j_decompress_ptr cinfo);
  void (*new_color_map) (j_decompress_ptr cinfo);
};
# 334 "jpegint.h"
extern void jinit_compress_master (j_compress_ptr cinfo);
extern void jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only);

extern void jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer);

extern void jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer);

extern void jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer);

extern void jinit_color_converter (j_compress_ptr cinfo);
extern void jinit_downsampler (j_compress_ptr cinfo);
extern void jinit_forward_dct (j_compress_ptr cinfo);
extern void jinit_huff_encoder (j_compress_ptr cinfo);
extern void jinit_phuff_encoder (j_compress_ptr cinfo);
extern void jinit_marker_writer (j_compress_ptr cinfo);

extern void jinit_master_decompress (j_decompress_ptr cinfo);
extern void jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer);

extern void jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer);

extern void jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer);

extern void jinit_input_controller (j_decompress_ptr cinfo);
extern void jinit_marker_reader (j_decompress_ptr cinfo);
extern void jinit_huff_decoder (j_decompress_ptr cinfo);
extern void jinit_phuff_decoder (j_decompress_ptr cinfo);
extern void jinit_inverse_dct (j_decompress_ptr cinfo);
extern void jinit_upsampler (j_decompress_ptr cinfo);
extern void jinit_color_deconverter (j_decompress_ptr cinfo);
extern void jinit_1pass_quantizer (j_decompress_ptr cinfo);
extern void jinit_2pass_quantizer (j_decompress_ptr cinfo);
extern void jinit_merged_upsampler (j_decompress_ptr cinfo);

extern void jinit_memory_mgr (j_common_ptr cinfo);


extern long jdiv_round_up (long a, long b);
extern long jround_up (long a, long b);
extern void jcopy_sample_rows (JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols);


extern void jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks);

extern void jzero_far (void * target, size_t bytestozero);




extern const int jpeg_natural_order[];
# 1099 "jpeglib.h" 2
# 1 "jerror.h" 1
# 33 "jerror.h"
typedef enum {





JMSG_NOMESSAGE ,


JERR_ARITH_NOTIMPL ,

JERR_BAD_ALIGN_TYPE ,
JERR_BAD_ALLOC_CHUNK ,
JERR_BAD_BUFFER_MODE ,
JERR_BAD_COMPONENT_ID ,
JERR_BAD_DCT_COEF ,
JERR_BAD_DCTSIZE ,
JERR_BAD_HUFF_TABLE ,
JERR_BAD_IN_COLORSPACE ,
JERR_BAD_J_COLORSPACE ,
JERR_BAD_LENGTH ,
JERR_BAD_LIB_VERSION ,

JERR_BAD_MCU_SIZE ,
JERR_BAD_POOL_ID ,
JERR_BAD_PRECISION ,
JERR_BAD_PROGRESSION ,

JERR_BAD_PROG_SCRIPT ,

JERR_BAD_SAMPLING ,
JERR_BAD_SCAN_SCRIPT ,
JERR_BAD_STATE ,
JERR_BAD_STRUCT_SIZE ,

JERR_BAD_VIRTUAL_ACCESS ,
JERR_BUFFER_SIZE ,
JERR_CANT_SUSPEND ,
JERR_CCIR601_NOTIMPL ,
JERR_COMPONENT_COUNT ,
JERR_CONVERSION_NOTIMPL ,
JERR_DAC_INDEX ,
JERR_DAC_VALUE ,
JERR_DHT_INDEX ,
JERR_DQT_INDEX ,
JERR_EMPTY_IMAGE ,
JERR_EMS_READ ,
JERR_EMS_WRITE ,
JERR_EOI_EXPECTED ,
JERR_FILE_READ ,
JERR_FILE_WRITE ,
JERR_FRACT_SAMPLE_NOTIMPL ,
JERR_HUFF_CLEN_OVERFLOW ,
JERR_HUFF_MISSING_CODE ,
JERR_IMAGE_TOO_BIG ,
JERR_INPUT_EMPTY ,
JERR_INPUT_EOF ,
JERR_MISMATCHED_QUANT_TABLE ,

JERR_MISSING_DATA ,
JERR_MODE_CHANGE ,
JERR_NOTIMPL ,
JERR_NOT_COMPILED ,
JERR_NO_BACKING_STORE ,
JERR_NO_HUFF_TABLE ,
JERR_NO_IMAGE ,
JERR_NO_QUANT_TABLE ,
JERR_NO_SOI ,
JERR_OUT_OF_MEMORY ,
JERR_QUANT_COMPONENTS ,

JERR_QUANT_FEW_COLORS ,
JERR_QUANT_MANY_COLORS ,
JERR_SOF_DUPLICATE ,
JERR_SOF_NO_SOS ,
JERR_SOF_UNSUPPORTED ,
JERR_SOI_DUPLICATE ,
JERR_SOS_NO_SOF ,
JERR_TFILE_CREATE ,
JERR_TFILE_READ ,
JERR_TFILE_SEEK ,
JERR_TFILE_WRITE ,

JERR_TOO_LITTLE_DATA ,
JERR_UNKNOWN_MARKER ,
JERR_VIRTUAL_BUG ,
JERR_WIDTH_OVERFLOW ,
JERR_XMS_READ ,
JERR_XMS_WRITE ,
JMSG_COPYRIGHT ,
JMSG_VERSION ,
JTRC_16BIT_TABLES ,

JTRC_ADOBE ,

JTRC_APP0 ,
JTRC_APP14 ,
JTRC_DAC ,
JTRC_DHT ,
JTRC_DQT ,
JTRC_DRI ,
JTRC_EMS_CLOSE ,
JTRC_EMS_OPEN ,
JTRC_EOI ,
JTRC_HUFFBITS ,
JTRC_JFIF ,
JTRC_JFIF_BADTHUMBNAILSIZE ,

JTRC_JFIF_EXTENSION ,

JTRC_JFIF_THUMBNAIL ,
JTRC_MISC_MARKER ,
JTRC_PARMLESS_MARKER ,
JTRC_QUANTVALS ,
JTRC_QUANT_3_NCOLORS ,
JTRC_QUANT_NCOLORS ,
JTRC_QUANT_SELECTED ,
JTRC_RECOVERY_ACTION ,
JTRC_RST ,
JTRC_SMOOTH_NOTIMPL ,

JTRC_SOF ,
JTRC_SOF_COMPONENT ,
JTRC_SOI ,
JTRC_SOS ,
JTRC_SOS_COMPONENT ,
JTRC_SOS_PARAMS ,
JTRC_TFILE_CLOSE ,
JTRC_TFILE_OPEN ,
JTRC_THUMB_JPEG ,

JTRC_THUMB_PALETTE ,

JTRC_THUMB_RGB ,

JTRC_UNKNOWN_IDS ,

JTRC_XMS_CLOSE ,
JTRC_XMS_OPEN ,
JWRN_ADOBE_XFORM ,
JWRN_BOGUS_PROGRESSION ,

JWRN_EXTRANEOUS_DATA ,

JWRN_HIT_MARKER ,
JWRN_HUFF_BAD_CODE ,
JWRN_JFIF_MAJOR ,
JWRN_JPEG_EOF ,
JWRN_MUST_RESYNC ,

JWRN_NOT_SEQUENTIAL ,
JWRN_TOO_MUCH_DATA ,



  JMSG_LASTMSGCODE
} J_MESSAGE_CODE;
# 1100 "jpeglib.h" 2
# 22 "jdapimin.c" 2


int MMXAvailable;
int mmxsupport();







void
jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
{
  int i;


  static int cpuidDetected = 0;

  if(!cpuidDetected)
  {
    MMXAvailable = mmxsupport();
    cpuidDetected = 1;
  }







  cinfo->mem = ((void *)0);
  if (version != 62)
    ((cinfo)->err->msg_code = (JERR_BAD_LIB_VERSION), (cinfo)->err->msg_parm.i[0] = (62), (cinfo)->err->msg_parm.i[1] = (version), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
  if (structsize != ((size_t) sizeof(struct jpeg_decompress_struct)))
    ((cinfo)->err->msg_code = (JERR_BAD_STRUCT_SIZE), (cinfo)->err->msg_parm.i[0] = ((int) ((size_t) sizeof(struct jpeg_decompress_struct))), (cinfo)->err->msg_parm.i[1] = ((int) structsize), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
# 66 "jdapimin.c"
  {
    struct jpeg_error_mgr * err = cinfo->err;
    void * client_data = cinfo->client_data;
    (__extension__ (__builtin_constant_p ((size_t)(((size_t) sizeof(struct jpeg_decompress_struct)))) && ((size_t)(((size_t) sizeof(struct jpeg_decompress_struct)))) <= 16 ? (((size_t)(((size_t) sizeof(struct jpeg_decompress_struct)))) == 1 ? ({ void *__s = ((void *)(cinfo)); *((__uint8_t *) __s) = (__uint8_t) 0; __s; }) : ({ void *__s = ((void *)(cinfo)); union { unsigned int __ui; unsigned short int __usi; unsigned char __uc; } *__u = __s; __uint8_t __c = (__uint8_t) (0); switch ((unsigned int) ((size_t)(((size_t) sizeof(struct jpeg_decompress_struct))))) { case 15: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 11: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 7: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 3: __u->__usi = (unsigned short int) __c * 0x0101; __u = __extension__ ((void *) __u + 2); __u->__uc = (unsigned char) __c; break; case 14: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 10: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 6: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 2: __u->__usi = (unsigned short int) __c * 0x0101; break; case 13: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 9: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 5: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 1: __u->__uc = (unsigned char) __c; break; case 16: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 12: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 8: __u->__ui = __c * 0x01010101; __u = __extension__ ((void *) __u + 4); case 4: __u->__ui = __c * 0x01010101; case 0: break; } __s; })) : (__builtin_constant_p (0) && (0) == '\0' ? ({ void *__s = ((void *)(cinfo)); __builtin_memset (__s, '\0', (size_t)(((size_t) sizeof(struct jpeg_decompress_struct)))); __s; }) : memset ((void *)(cinfo), 0, (size_t)(((size_t) sizeof(struct jpeg_decompress_struct)))))));
    cinfo->err = err;
    cinfo->client_data = client_data;
  }
  cinfo->is_decompressor = 1;


  jinit_memory_mgr((j_common_ptr) cinfo);


  cinfo->progress = ((void *)0);
  cinfo->src = ((void *)0);

  for (i = 0; i < 4; i++)
    cinfo->quant_tbl_ptrs[i] = ((void *)0);

  for (i = 0; i < 4; i++) {
    cinfo->dc_huff_tbl_ptrs[i] = ((void *)0);
    cinfo->ac_huff_tbl_ptrs[i] = ((void *)0);
  }




  cinfo->marker_list = ((void *)0);
  jinit_marker_reader(cinfo);


  jinit_input_controller(cinfo);


  cinfo->global_state = 200;
}






void
jpeg_destroy_decompress (j_decompress_ptr cinfo)
{
  jpeg_destroy((j_common_ptr) cinfo);
}







void
jpeg_abort_decompress (j_decompress_ptr cinfo)
{
  jpeg_abort((j_common_ptr) cinfo);
}





static void
default_decompress_parms (j_decompress_ptr cinfo)
{



  switch (cinfo->num_components) {
  case 1:
    cinfo->jpeg_color_space = JCS_GRAYSCALE;
    cinfo->out_color_space = JCS_GRAYSCALE;
    break;

  case 3:
    if (cinfo->saw_JFIF_marker) {
      cinfo->jpeg_color_space = JCS_YCbCr;
    } else if (cinfo->saw_Adobe_marker) {
      switch (cinfo->Adobe_transform) {
      case 0:
        cinfo->jpeg_color_space = JCS_RGB;
        break;
      case 1:
        cinfo->jpeg_color_space = JCS_YCbCr;
        break;
      default:
        ((cinfo)->err->msg_code = (JWRN_ADOBE_XFORM), (cinfo)->err->msg_parm.i[0] = (cinfo->Adobe_transform), (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1));
        cinfo->jpeg_color_space = JCS_YCbCr;
        break;
      }
    } else {

      int cid0 = cinfo->comp_info[0].component_id;
      int cid1 = cinfo->comp_info[1].component_id;
      int cid2 = cinfo->comp_info[2].component_id;

      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
        cinfo->jpeg_color_space = JCS_YCbCr;
      else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
        cinfo->jpeg_color_space = JCS_RGB;
      else {
        do { int * _mp = (cinfo)->err->msg_parm.i; _mp[0] = (cid0); _mp[1] = (cid1); _mp[2] = (cid2); (cinfo)->err->msg_code = (JTRC_UNKNOWN_IDS); (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (1)); } while (0);
        cinfo->jpeg_color_space = JCS_YCbCr;
      }
    }

    cinfo->out_color_space = JCS_RGB;
    break;

  case 4:
    if (cinfo->saw_Adobe_marker) {
      switch (cinfo->Adobe_transform) {
      case 0:
        cinfo->jpeg_color_space = JCS_CMYK;
        break;
      case 2:
        cinfo->jpeg_color_space = JCS_YCCK;
        break;
      default:
        ((cinfo)->err->msg_code = (JWRN_ADOBE_XFORM), (cinfo)->err->msg_parm.i[0] = (cinfo->Adobe_transform), (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1));
        cinfo->jpeg_color_space = JCS_YCCK;
        break;
      }
    } else {

      cinfo->jpeg_color_space = JCS_CMYK;
    }
    cinfo->out_color_space = JCS_CMYK;
    break;

  default:
    cinfo->jpeg_color_space = JCS_UNKNOWN;
    cinfo->out_color_space = JCS_UNKNOWN;
    break;
  }


  cinfo->scale_num = 1;
  cinfo->scale_denom = 1;
  cinfo->output_gamma = 1.0;
  cinfo->buffered_image = 0;
  cinfo->raw_data_out = 0;
  cinfo->dct_method = JDCT_ISLOW;
  cinfo->do_fancy_upsampling = 1;
  cinfo->do_block_smoothing = 1;
  cinfo->quantize_colors = 0;

  cinfo->dither_mode = JDITHER_FS;

  cinfo->two_pass_quantize = 1;



  cinfo->desired_number_of_colors = 256;
  cinfo->colormap = ((void *)0);

  cinfo->enable_1pass_quant = 0;
  cinfo->enable_external_quant = 0;
  cinfo->enable_2pass_quant = 0;
}
# 257 "jdapimin.c"
int
jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
{
  int retcode;

  if (cinfo->global_state != 200 &&
      cinfo->global_state != 201)
    ((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));

  retcode = jpeg_consume_input(cinfo);

  switch (retcode) {
  case 1:
    retcode = 1;
    break;
  case 2:
    if (require_image)
      ((cinfo)->err->msg_code = (JERR_NO_IMAGE), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));




    jpeg_abort((j_common_ptr) cinfo);
    retcode = 2;
    break;
  case 0:

    break;
  }

  return retcode;
}
# 303 "jdapimin.c"
int
jpeg_consume_input (j_decompress_ptr cinfo)
{
  int retcode = 0;


  switch (cinfo->global_state) {
  case 200:

    (*cinfo->inputctl->reset_input_controller) (cinfo);

    (*cinfo->src->init_source) (cinfo);
    cinfo->global_state = 201;

  case 201:
    retcode = (*cinfo->inputctl->consume_input) (cinfo);
    if (retcode == 1) {

      default_decompress_parms(cinfo);

      cinfo->global_state = 202;
    }
    break;
  case 202:

    retcode = 1;
    break;
  case 203:
  case 204:
  case 205:
  case 206:
  case 207:
  case 208:
  case 210:
    retcode = (*cinfo->inputctl->consume_input) (cinfo);
    break;
  default:
    ((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
  }
  return retcode;
}






boolean
jpeg_input_complete (j_decompress_ptr cinfo)
{

  if (cinfo->global_state < 200 ||
      cinfo->global_state > 210)
    ((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
  return cinfo->inputctl->eoi_reached;
}






boolean
jpeg_has_multiple_scans (j_decompress_ptr cinfo)
{

  if (cinfo->global_state < 202 ||
      cinfo->global_state > 210)
    ((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
  return cinfo->inputctl->has_multiple_scans;
}
# 385 "jdapimin.c"
boolean
jpeg_finish_decompress (j_decompress_ptr cinfo)
{
  if ((cinfo->global_state == 205 ||
       cinfo->global_state == 206) && ! cinfo->buffered_image) {

    if (cinfo->output_scanline < cinfo->output_height)
      ((cinfo)->err->msg_code = (JERR_TOO_LITTLE_DATA), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
    (*cinfo->master->finish_output_pass) (cinfo);
    cinfo->global_state = 210;
  } else if (cinfo->global_state == 207) {

    cinfo->global_state = 210;
  } else if (cinfo->global_state != 210) {

    ((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
  }

  while (! cinfo->inputctl->eoi_reached) {
    if ((*cinfo->inputctl->consume_input) (cinfo) == 0)
      return 0;
  }

  (*cinfo->src->term_source) (cinfo);

  jpeg_abort((j_common_ptr) cinfo);
  return 1;
}


static int mmx_supported = 0;
int mmxsupport()
{
# 463 "jdapimin.c"
        __asm__ (
                "pushfl                      \n\t"
                "popl %%eax                   \n\t"
                "movl %%eax,%%ecx              \n\t"
                "xorl $0x200000,%%eax         \n\t"
                "pushl %%eax                  \n\t"

                "popfl                       \n\t"
                "pushfl                      \n\t"
                "popl %%eax                   \n\t"
                "xorl %%ecx,%%eax              \n\t"
                "jz NOT_SUPPORTED            \n\t"



                "xorl %%eax,%%eax              \n\t"

                "cpuid                       \n\t"

                "cmpl $1,%%eax                \n\t"
                "jl NOT_SUPPORTED            \n\t"

                "xorl %%eax,%%eax              \n\t"
                "incl %%eax                   \n\t"

                "cpuid                       \n\t"

                "andl $0x00800000,%%edx       \n\t"
                "cmpl $0,%%edx                \n\t"
                "jz      NOT_SUPPORTED       \n\t"

                 "movl   $1,  mmx_supported  \n\t"

                "NOT_SUPPORTED:              \n\t"
                "movl    $mmx_supported, %%eax"


           : "=m" (mmx_supported)

           :

           : "eax", "ebx", "ecx", "edx", "cc", "memory");


        return mmx_supported;
}