Initial commit of comm-esr52.6

51 files changed, 4588 insertions, 0 deletions

diff --git a/build/autoconf/check-sync-exceptions b/build/autoconf/check-sync-exceptions
new file mode 100644
index 000000000..005bb6b5e
--- /dev/null
+++ b/build/autoconf/check-sync-exceptions
@@ -0,0 +1,2 @@
+mozconfig-find
+mozconfig2client-mk
diff --git a/build/autoconf/config.guess b/build/autoconf/config.guess
new file mode 100644
index 000000000..d5d667d4a
--- /dev/null
+++ b/build/autoconf/config.guess
@@ -0,0 +1,1454 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright 1992-2016 Free Software Foundation, Inc.
+
+timestamp='2016-03-24'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
+#
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+#
+# Please send patches to <config-patches@gnu.org>.
+
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright 1992-2016 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > $dummy.c ;
+	for c in cc gcc c89 c99 ; do
+	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found ;
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+case "${UNAME_SYSTEM}" in
+Linux|GNU|GNU/*)
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	LIBC=gnu
+
+	eval $set_cc_for_build
+	cat <<-EOF > $dummy.c
+	#include <features.h>
+	#if defined(__UCLIBC__)
+	LIBC=uclibc
+	#elif defined(__dietlibc__)
+	LIBC=dietlibc
+	#else
+	LIBC=gnu
+	#endif
+	EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+	;;
+esac
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+	# NetBSD (nbsd) targets should (where applicable) match one or
+	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+	    /sbin/$sysctl 2>/dev/null || \
+	    /usr/sbin/$sysctl 2>/dev/null || \
+	    echo unknown)`
+	case "${UNAME_MACHINE_ARCH}" in
+	    armeb) machine=armeb-unknown ;;
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
+	    earmv*)
+		arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+		endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
+		machine=${arch}${endian}-unknown
+		;;
+	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+	esac
+	# The Operating System including object format, if it has switched
+	# to ELF recently, or will in the future.
+	case "${UNAME_MACHINE_ARCH}" in
+	    arm*|earm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval $set_cc_for_build
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep -q __ELF__
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+		os=netbsd
+		;;
+	esac
+	# Determine ABI tags.
+	case "${UNAME_MACHINE_ARCH}" in
+	    earm*)
+		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
+		abi=`echo ${UNAME_MACHINE_ARCH} | sed -e "$expr"`
+		;;
+	esac
+	# The OS release
+	# Debian GNU/NetBSD machines have a different userland, and
+	# thus, need a distinct triplet. However, they do not need
+	# kernel version information, so it can be replaced with a
+	# suitable tag, in the style of linux-gnu.
+	case "${UNAME_VERSION}" in
+	    Debian*)
+		release='-gnu'
+		;;
+	    *)
+		release=`echo ${UNAME_RELEASE} | sed -e 's/[-_].*//' | cut -d. -f1,2`
+		;;
+	esac
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "${machine}-${os}${release}${abi}"
+	exit ;;
+    *:Bitrig:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+	exit ;;
+    *:OpenBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+	exit ;;
+    *:LibertyBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-libertybsd${UNAME_RELEASE}
+	exit ;;
+    *:ekkoBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+	exit ;;
+    *:SolidBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+	exit ;;
+    macppc:MirBSD:*:*)
+	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    *:MirBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    *:Sortix:*:*)
+	echo ${UNAME_MACHINE}-unknown-sortix
+	exit ;;
+    alpha:OSF1:*:*)
+	case $UNAME_RELEASE in
+	*4.0)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+		;;
+	*5.*)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		;;
+	esac
+	# According to Compaq, /usr/sbin/psrinfo has been available on
+	# OSF/1 and Tru64 systems produced since 1995.  I hope that
+	# covers most systems running today.  This code pipes the CPU
+	# types through head -n 1, so we only detect the type of CPU 0.
+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+	case "$ALPHA_CPU_TYPE" in
+	    "EV4 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "EV4.5 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "LCA4 (21066/21068)")
+		UNAME_MACHINE=alpha ;;
+	    "EV5 (21164)")
+		UNAME_MACHINE=alphaev5 ;;
+	    "EV5.6 (21164A)")
+		UNAME_MACHINE=alphaev56 ;;
+	    "EV5.6 (21164PC)")
+		UNAME_MACHINE=alphapca56 ;;
+	    "EV5.7 (21164PC)")
+		UNAME_MACHINE=alphapca57 ;;
+	    "EV6 (21264)")
+		UNAME_MACHINE=alphaev6 ;;
+	    "EV6.7 (21264A)")
+		UNAME_MACHINE=alphaev67 ;;
+	    "EV6.8CB (21264C)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8AL (21264B)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8CX (21264D)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.9A (21264/EV69A)")
+		UNAME_MACHINE=alphaev69 ;;
+	    "EV7 (21364)")
+		UNAME_MACHINE=alphaev7 ;;
+	    "EV7.9 (21364A)")
+		UNAME_MACHINE=alphaev79 ;;
+	esac
+	# A Pn.n version is a patched version.
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	exitcode=$?
+	trap '' 0
+	exit $exitcode ;;
+    Alpha\ *:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# Should we change UNAME_MACHINE based on the output of uname instead
+	# of the specific Alpha model?
+	echo alpha-pc-interix
+	exit ;;
+    21064:Windows_NT:50:3)
+	echo alpha-dec-winnt3.5
+	exit ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-unknown-sysv4
+	exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-amigaos
+	exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-morphos
+	exit ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit ;;
+    *:z/VM:*:*)
+	echo s390-ibm-zvmoe
+	exit ;;
+    *:OS400:*:*)
+	echo powerpc-ibm-os400
+	exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix${UNAME_RELEASE}
+	exit ;;
+    arm*:riscos:*:*|arm*:RISCOS:*:*)
+	echo arm-unknown-riscos
+	exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit ;;
+    DRS?6000:unix:4.0:6*)
+	echo sparc-icl-nx6
+	exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+	case `/usr/bin/uname -p` in
+	    sparc) echo sparc-icl-nx7; exit ;;
+	esac ;;
+    s390x:SunOS:*:*)
+	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+	echo i386-pc-auroraux${UNAME_RELEASE}
+	exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+	eval $set_cc_for_build
+	SUN_ARCH=i386
+	# If there is a compiler, see if it is configured for 64-bit objects.
+	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+	# This test works for both compilers.
+	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_64BIT_ARCH >/dev/null
+	    then
+		SUN_ARCH=x86_64
+	    fi
+	fi
+	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	exit ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos${UNAME_RELEASE}
+	exit ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x${UNAME_RELEASE}" = x && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos${UNAME_RELEASE}
+		;;
+	    sun4)
+		echo sparc-sun-sunos${UNAME_RELEASE}
+		;;
+	esac
+	exit ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos${UNAME_RELEASE}
+	exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+	echo m68k-milan-mint${UNAME_RELEASE}
+	exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+	echo m68k-hades-mint${UNAME_RELEASE}
+	exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+	echo m68k-unknown-mint${UNAME_RELEASE}
+	exit ;;
+    m68k:machten:*:*)
+	echo m68k-apple-machten${UNAME_RELEASE}
+	exit ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten${UNAME_RELEASE}
+	exit ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix${UNAME_RELEASE}
+	exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c &&
+	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+	  SYSTEM_NAME=`$dummy $dummyarg` &&
+	    { echo "$SYSTEM_NAME"; exit; }
+	echo mips-mips-riscos${UNAME_RELEASE}
+	exit ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit ;;
+    Motorola:*:4.3:PL8-*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit ;;
+    AViiON:dgux:*:*)
+	# DG/UX returns AViiON for all architectures
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+	then
+	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+	       [ ${TARGET_BINARY_INTERFACE}x = x ]
+	    then
+		echo m88k-dg-dgux${UNAME_RELEASE}
+	    else
+		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+	    fi
+	else
+	    echo i586-dg-dgux${UNAME_RELEASE}
+	fi
+	exit ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+	echo i386-ibm-aix
+	exit ;;
+    ia64:AIX:*:*)
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval $set_cc_for_build
+		sed 's/^		//' << EOF >$dummy.c
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+		then
+			echo "$SYSTEM_NAME"
+		else
+			echo rs6000-ibm-aix3.2.5
+		fi
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit ;;
+    *:AIX:*:[4567])
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/lslpp ] ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+	echo romp-ibm-bsd4.4
+	exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+	exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit ;;
+    9000/[34678]??:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	case "${UNAME_MACHINE}" in
+	    9000/31? )            HP_ARCH=m68000 ;;
+	    9000/[34]?? )         HP_ARCH=m68k ;;
+	    9000/[678][0-9][0-9])
+		if [ -x /usr/bin/getconf ]; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+		    case "${sc_cpu_version}" in
+		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
+		      532)                      # CPU_PA_RISC2_0
+			case "${sc_kernel_bits}" in
+			  32) HP_ARCH=hppa2.0n ;;
+			  64) HP_ARCH=hppa2.0w ;;
+			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
+			esac ;;
+		    esac
+		fi
+		if [ "${HP_ARCH}" = "" ]; then
+		    eval $set_cc_for_build
+		    sed 's/^		//' << EOF >$dummy.c
+
+		#define _HPUX_SOURCE
+		#include <stdlib.h>
+		#include <unistd.h>
+
+		int main ()
+		{
+		#if defined(_SC_KERNEL_BITS)
+		    long bits = sysconf(_SC_KERNEL_BITS);
+		#endif
+		    long cpu  = sysconf (_SC_CPU_VERSION);
+
+		    switch (cpu)
+			{
+			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+			case CPU_PA_RISC2_0:
+		#if defined(_SC_KERNEL_BITS)
+			    switch (bits)
+				{
+				case 64: puts ("hppa2.0w"); break;
+				case 32: puts ("hppa2.0n"); break;
+				default: puts ("hppa2.0"); break;
+				} break;
+		#else  /* !defined(_SC_KERNEL_BITS) */
+			    puts ("hppa2.0"); break;
+		#endif
+			default: puts ("hppa1.0"); break;
+			}
+		    exit (0);
+		}
+EOF
+		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+		    test -z "$HP_ARCH" && HP_ARCH=hppa
+		fi ;;
+	esac
+	if [ ${HP_ARCH} = hppa2.0w ]
+	then
+	    eval $set_cc_for_build
+
+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+	    # generating 64-bit code.  GNU and HP use different nomenclature:
+	    #
+	    # $ CC_FOR_BUILD=cc ./config.guess
+	    # => hppa2.0w-hp-hpux11.23
+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+	    # => hppa64-hp-hpux11.23
+
+	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+		grep -q __LP64__
+	    then
+		HP_ARCH=hppa2.0w
+	    else
+		HP_ARCH=hppa64
+	    fi
+	fi
+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	exit ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ia64-hp-hpux${HPUX_REV}
+	exit ;;
+    3050*:HI-UX:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+		{ echo "$SYSTEM_NAME"; exit; }
+	echo unknown-hitachi-hiuxwe2
+	exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+	echo hppa1.1-hp-bsd
+	exit ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+	echo hppa1.1-hp-osf
+	exit ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit ;;
+    i*86:OSF1:*:*)
+	if [ -x /usr/sbin/sysversion ] ; then
+	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	else
+	    echo ${UNAME_MACHINE}-unknown-osf1
+	fi
+	exit ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+	exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+	exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+	exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+	exit ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*[A-Z]90:*:*:*)
+	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    *:UNICOS/mp:*:*)
+	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    5000:UNIX_System_V:4.*:*)
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
+	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+	exit ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:BSD/OS:*:*)
+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:FreeBSD:*:*)
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	case ${UNAME_PROCESSOR} in
+	    amd64)
+		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	    *)
+		echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	esac
+	exit ;;
+    i*:CYGWIN*:*)
+	echo ${UNAME_MACHINE}-pc-cygwin
+	exit ;;
+    *:MINGW64*:*)
+	echo ${UNAME_MACHINE}-pc-mingw64
+	exit ;;
+    *:MINGW*:*)
+	echo ${UNAME_MACHINE}-pc-mingw32
+	exit ;;
+    *:MSYS*:*)
+	echo ${UNAME_MACHINE}-pc-msys
+	exit ;;
+    i*:windows32*:*)
+	# uname -m includes "-pc" on this system.
+	echo ${UNAME_MACHINE}-mingw32
+	exit ;;
+    i*:PW*:*)
+	echo ${UNAME_MACHINE}-pc-pw32
+	exit ;;
+    *:Interix*:*)
+	case ${UNAME_MACHINE} in
+	    x86)
+		echo i586-pc-interix${UNAME_RELEASE}
+		exit ;;
+	    authenticamd | genuineintel | EM64T)
+		echo x86_64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	    IA64)
+		echo ia64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	esac ;;
+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+	echo i${UNAME_MACHINE}-pc-mks
+	exit ;;
+    8664:Windows_NT:*)
+	echo x86_64-pc-mks
+	exit ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+	# UNAME_MACHINE based on the output of uname instead of i386?
+	echo i586-pc-interix
+	exit ;;
+    i*:UWIN*:*)
+	echo ${UNAME_MACHINE}-pc-uwin
+	exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+	echo x86_64-unknown-cygwin
+	exit ;;
+    p*:CYGWIN*:*)
+	echo powerpcle-unknown-cygwin
+	exit ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    *:GNU:*:*)
+	# the GNU system
+	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	exit ;;
+    *:GNU/*:*:*)
+	# other systems with GNU libc and userland
+	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
+	exit ;;
+    i*86:Minix:*:*)
+	echo ${UNAME_MACHINE}-pc-minix
+	exit ;;
+    aarch64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    aarch64_be:Linux:*:*)
+	UNAME_MACHINE=aarch64_be
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    alpha:Linux:*:*)
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+	esac
+	objdump --private-headers /bin/sh | grep -q ld.so.1
+	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    arc:Linux:*:* | arceb:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    arm*:Linux:*:*)
+	eval $set_cc_for_build
+	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_EABI__
+	then
+	    echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	else
+	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep -q __ARM_PCS_VFP
+	    then
+		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+	    else
+		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+	    fi
+	fi
+	exit ;;
+    avr32*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    cris:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	exit ;;
+    crisv32:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	exit ;;
+    e2k:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    frv:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    hexagon:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    i*86:Linux:*:*)
+	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+	exit ;;
+    ia64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    k1om:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m32r*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m68*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef ${UNAME_MACHINE}
+	#undef ${UNAME_MACHINE}el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=${UNAME_MACHINE}el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=${UNAME_MACHINE}
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	;;
+    openrisc*:Linux:*:*)
+	echo or1k-unknown-linux-${LIBC}
+	exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    padre:Linux:*:*)
+	echo sparc-unknown-linux-${LIBC}
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-${LIBC}
+	exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+	  *)    echo hppa-unknown-linux-${LIBC} ;;
+	esac
+	exit ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-${LIBC}
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-${LIBC}
+	exit ;;
+    ppc64le:Linux:*:*)
+	echo powerpc64le-unknown-linux-${LIBC}
+	exit ;;
+    ppcle:Linux:*:*)
+	echo powerpcle-unknown-linux-${LIBC}
+	exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
+	exit ;;
+    sh64*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sh*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    tile*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    vax:Linux:*:*)
+	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+	exit ;;
+    x86_64:Linux:*:*)
+	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+	exit ;;
+    xtensa*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
+	echo i386-sequent-sysv4
+	exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+	# Unixware is an offshoot of SVR4, but it has its own version
+	# number series starting with 2...
+	# I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+	# Use sysv4.2uw... so that sysv4* matches it.
+	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+	exit ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo ${UNAME_MACHINE}-pc-os2-emx
+	exit ;;
+    i*86:XTS-300:*:STOP)
+	echo ${UNAME_MACHINE}-unknown-stop
+	exit ;;
+    i*86:atheos:*:*)
+	echo ${UNAME_MACHINE}-unknown-atheos
+	exit ;;
+    i*86:syllable:*:*)
+	echo ${UNAME_MACHINE}-pc-syllable
+	exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+	echo i386-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    i*86:*DOS:*:*)
+	echo ${UNAME_MACHINE}-pc-msdosdjgpp
+	exit ;;
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+	else
+		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+	fi
+	exit ;;
+    i*86:*:5:[678]*)
+	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	exit ;;
+    i*86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+	else
+		echo ${UNAME_MACHINE}-pc-sysv32
+	fi
+	exit ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+	# uname -m prints for DJGPP always 'pc', but it prints nothing about
+	# the processor, so we play safe by assuming i586.
+	# Note: whatever this is, it MUST be the same as what config.sub
+	# prints for the "djgpp" host, or else GDB configure will decide that
+	# this is a cross-build.
+	echo i586-pc-msdosdjgpp
+	exit ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	fi
+	exit ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+	echo m68k-convergent-sysv
+	exit ;;
+    M680?0:D-NIX:5.3:*)
+	echo m68k-diab-dnix
+	exit ;;
+    M68*:*:R3V[5678]*:*)
+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+	OS_REL='.3'
+	test -r /etc/.relid \
+	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+	echo m68k-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    rs6000:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+	echo powerpc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+	echo mips-dde-sysv${UNAME_RELEASE}
+	exit ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo ${UNAME_MACHINE}-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit ;;
+    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+			# says <Richard.M.Bartel@ccMail.Census.GOV>
+	echo i586-unisys-sysv4
+	exit ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit ;;
+    i*86:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo ${UNAME_MACHINE}-stratus-vos
+	exit ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux${UNAME_RELEASE}
+	exit ;;
+    news*:NEWS-OS:6*:*)
+	echo mips-sony-newsos6
+	exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if [ -d /usr/nec ]; then
+		echo mips-nec-sysv${UNAME_RELEASE}
+	else
+		echo mips-unknown-sysv${UNAME_RELEASE}
+	fi
+	exit ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit ;;
+    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
+	echo i586-pc-haiku
+	exit ;;
+    x86_64:Haiku:*:*)
+	echo x86_64-unknown-haiku
+	exit ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-6:SUPER-UX:*:*)
+	echo sx6-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-ACE:SUPER-UX:*:*)
+	echo sxace-nec-superux${UNAME_RELEASE}
+	exit ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Rhapsody:*:*)
+	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Darwin:*:*)
+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+	eval $set_cc_for_build
+	if test "$UNAME_PROCESSOR" = unknown ; then
+	    UNAME_PROCESSOR=powerpc
+	fi
+	if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
+	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		    (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+		    grep IS_64BIT_ARCH >/dev/null
+		then
+		    case $UNAME_PROCESSOR in
+			i386) UNAME_PROCESSOR=x86_64 ;;
+			powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		    esac
+		fi
+	    fi
+	elif test "$UNAME_PROCESSOR" = i386 ; then
+	    # Avoid executing cc on OS X 10.9, as it ships with a stub
+	    # that puts up a graphical alert prompting to install
+	    # developer tools.  Any system running Mac OS X 10.7 or
+	    # later (Darwin 11 and later) is required to have a 64-bit
+	    # processor. This is not true of the ARM version of Darwin
+	    # that Apple uses in portable devices.
+	    UNAME_PROCESSOR=x86_64
+	fi
+	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+	exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+	UNAME_PROCESSOR=`uname -p`
+	if test "$UNAME_PROCESSOR" = x86; then
+		UNAME_PROCESSOR=i386
+		UNAME_MACHINE=pc
+	fi
+	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+	exit ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit ;;
+    NEO-?:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
+	echo nse-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSR-?:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit ;;
+    DS/*:UNIX_System_V:*:*)
+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+	exit ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = 386; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo ${UNAME_MACHINE}-unknown-plan9
+	exit ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit ;;
+    SEI:*:*:SEIUX)
+	echo mips-sei-seiux${UNAME_RELEASE}
+	exit ;;
+    *:DragonFly:*:*)
+	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+	exit ;;
+    *:*VMS:*:*)
+	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	case "${UNAME_MACHINE}" in
+	    A*) echo alpha-dec-vms ; exit ;;
+	    I*) echo ia64-dec-vms ; exit ;;
+	    V*) echo vax-dec-vms ; exit ;;
+	esac ;;
+    *:XENIX:*:SysV)
+	echo i386-pc-xenix
+	exit ;;
+    i*86:skyos:*:*)
+	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+	exit ;;
+    i*86:rdos:*:*)
+	echo ${UNAME_MACHINE}-pc-rdos
+	exit ;;
+    i*86:AROS:*:*)
+	echo ${UNAME_MACHINE}-pc-aros
+	exit ;;
+    x86_64:VMkernel:*:*)
+	echo ${UNAME_MACHINE}-unknown-esx
+	exit ;;
+    amd64:Isilon\ OneFS:*:*)
+	echo x86_64-unknown-onefs
+	exit ;;
+esac
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+and
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/build/autoconf/mozconfig-find b/build/autoconf/mozconfig-find
new file mode 100644
index 000000000..97dd90c35
--- /dev/null
+++ b/build/autoconf/mozconfig-find
@@ -0,0 +1,76 @@
+#! /bin/sh
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# mozconfigfind - Loads options from .mozconfig onto configure's
+#    command-line. The .mozconfig file is searched for in the 
+#    order:
+#       If $MOZCONFIG is set, use that.
+#       If one of $TOPSRCDIR/.mozconfig or $TOPSRCDIR/mozconfig exists, use it.
+#       If both exist, or if various legacy locations contain a mozconfig, error.
+#       Otherwise, use the default build options.
+#
+topsrcdir=$1
+
+abspath() {
+  if uname -s | grep -q MINGW; then
+    # We have no way to figure out whether we're in gmake or pymake right
+    # now. gmake gives us Unix-style paths while pymake gives us Windows-style
+    # paths, so attempt to handle both.
+    regexes='^\([A-Za-z]:\|\\\\\|\/\) ^\/'
+  else
+    regexes='^\/'
+  fi
+
+  for regex in $regexes; do
+    if echo $1 | grep -q $regex; then
+      echo $1
+      return
+    fi
+  done
+
+  # If we're at this point, we have a relative path
+  echo `pwd`/$1
+}
+
+if [ -n "$MOZCONFIG" ] && ! [ -f "$MOZCONFIG" ]; then
+  echo "Specified MOZCONFIG \"$MOZCONFIG\" does not exist!" 1>&2
+  exit 1
+fi
+
+if [ -n "$MOZ_MYCONFIG" ]; then
+  echo "Your environment currently has the MOZ_MYCONFIG variable set to \"$MOZ_MYCONFIG\". MOZ_MYCONFIG is no longer supported. Please use MOZCONFIG instead." 1>&2
+  exit 1
+fi
+
+if [ -z "$MOZCONFIG" ] && [ -f "$topsrcdir/.mozconfig" ] && [ -f "$topsrcdir/mozconfig" ]; then
+  echo "Both \$topsrcdir/.mozconfig and \$topsrcdir/mozconfig are supported, but you must choose only one. Please remove the other." 1>&2
+  exit 1
+fi
+
+for _config in "$MOZCONFIG" \
+               "$topsrcdir/.mozconfig" \
+               "$topsrcdir/mozconfig"
+do
+  if test -f "$_config"; then
+    abspath $_config
+    exit 0
+  fi
+done
+
+# We used to support a number of other implicit .mozconfig locations. We now
+# detect if we were about to use any of these locations and issue an error if we
+# find any.
+for _config in "$topsrcdir/mozconfig.sh" \
+               "$topsrcdir/myconfig.sh" \
+               "$HOME/.mozconfig" \
+               "$HOME/.mozconfig.sh" \
+               "$HOME/.mozmyconfig.sh"
+do
+  if test -f "$_config"; then
+    echo "You currently have a mozconfig at \"$_config\". This implicit location is no longer supported. Please move it to $topsrcdir/.mozconfig or specify it explicitly via \$MOZCONFIG." 1>&2
+    exit 1
+  fi
+done
diff --git a/build/autoconf/mozconfig2client-mk b/build/autoconf/mozconfig2client-mk
new file mode 100644
index 000000000..aaf8de185
--- /dev/null
+++ b/build/autoconf/mozconfig2client-mk
@@ -0,0 +1,76 @@
+#! /bin/sh
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# mozconfig2client-mk - Translates .mozconfig into options for client.mk.
+#    Prints defines to stdout.
+#
+# See mozconfig2configure for more details
+
+print_header() {
+  cat <<EOF
+# gmake
+# This file is automatically generated for client.mk.
+# Do not edit. Edit $FOUND_MOZCONFIG instead.
+
+EOF
+}
+
+ac_add_options() {
+  for _opt
+  do
+    case "$_opt" in
+    --target=*)
+      echo $_opt | sed s/--target/CONFIG_GUESS/
+      ;;
+    *)
+      echo "# $_opt is used by configure (not client.mk)"
+      ;;
+    esac
+  done
+}
+
+ac_add_app_options() {
+  echo "# $* is used by configure (not client.mk)"
+}
+
+mk_add_options() {
+  for _opt
+  do
+    # Escape shell characters, space, tab, dollar, quote, backslash,
+    # and substitute '@<word>@' with '$(<word>)'.
+    _opt=`echo "$_opt" | sed -e 's/\([\"\\]\)/\\\\\1/g; s/@\([^@]*\)@/\$(\1)/g;'`
+    echo $_opt;
+  done
+}
+
+# Main
+#--------------------------------------------------
+
+scriptdir=`dirname $0`
+topsrcdir=$1
+
+# If the path changes, configure should be rerun
+echo "# PATH=$PATH"
+
+# If FOUND_MOZCONFIG isn't set, look for it and make sure the script doesn't error out
+isfoundset=${FOUND_MOZCONFIG+yes}
+if [ -z $isfoundset ]; then
+  FOUND_MOZCONFIG=`$scriptdir/mozconfig-find $topsrcdir`
+  if [ $? -ne 0 ]; then
+    echo '$(error Fix above errors before continuing.)'
+  else
+    isfoundset=yes
+  fi
+fi
+
+if [ -n $isfoundset ]; then
+  if [ "$FOUND_MOZCONFIG" ]
+  then
+    print_header
+    . "$FOUND_MOZCONFIG"
+    echo "FOUND_MOZCONFIG := $FOUND_MOZCONFIG"
+  fi
+fi
diff --git a/build/check-sync-exceptions b/build/check-sync-exceptions
new file mode 100644
index 000000000..de0da9f6f
--- /dev/null
+++ b/build/check-sync-exceptions
@@ -0,0 +1,17 @@
+dumbmake-dependencies
+mach_bootstrap.py
+merge-installrdf.py
+pymake
+client.py-args
+client.py-l10n-args
+configobj.py
+
+# Ignore detritus left lying around by editing tools.
+*~
+.#*
+#*#
+*.orig
+*.rej
+
+# Ignore "compiled" python files
+*.pyc
diff --git a/build/client.py-args b/build/client.py-args
new file mode 100644
index 000000000..4f38e4ea2
--- /dev/null
+++ b/build/client.py-args
@@ -0,0 +1 @@
+--hg-options='--time' --hgtool=../tools/buildfarm/utils/hgtool.py --hgtool1=../scripts/buildfarm/utils/hgtool.py --skip-chatzilla --skip-comm --skip-inspector --tinderbox-print --mozilla-repo=https://hg.mozilla.org/releases/mozilla-esr52 --mozilla-rev=THUNDERBIRD_52_VERBRANCH
diff --git a/build/client.py-l10n-args b/build/client.py-l10n-args
new file mode 100644
index 000000000..4f38e4ea2
--- /dev/null
+++ b/build/client.py-l10n-args
@@ -0,0 +1 @@
+--hg-options='--time' --hgtool=../tools/buildfarm/utils/hgtool.py --hgtool1=../scripts/buildfarm/utils/hgtool.py --skip-chatzilla --skip-comm --skip-inspector --tinderbox-print --mozilla-repo=https://hg.mozilla.org/releases/mozilla-esr52 --mozilla-rev=THUNDERBIRD_52_VERBRANCH
diff --git a/build/dumbmake-dependencies b/build/dumbmake-dependencies
new file mode 100644
index 000000000..7704a681a
--- /dev/null
+++ b/build/dumbmake-dependencies
@@ -0,0 +1,6 @@
+im/app
+    chat
+    im
+    mozilla/extensions/purple
+chat
+    im
diff --git a/build/mach_bootstrap.py b/build/mach_bootstrap.py
new file mode 100644
index 000000000..ed79f3abc
--- /dev/null
+++ b/build/mach_bootstrap.py
@@ -0,0 +1,14 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from __future__ import unicode_literals
+
+import os, sys
+
+def bootstrap(topsrcdir, mozilla_dir=None):
+    if mozilla_dir is None:
+        mozilla_dir = os.path.join(topsrcdir, 'mozilla')
+    sys.path[0:0] = [mozilla_dir]
+    import build.mach_bootstrap
+    return build.mach_bootstrap.bootstrap(topsrcdir, mozilla_dir)
diff --git a/build/macosx/cross-mozconfig.common b/build/macosx/cross-mozconfig.common
new file mode 100644
index 000000000..8e56394d0
--- /dev/null
+++ b/build/macosx/cross-mozconfig.common
@@ -0,0 +1,47 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+MOZ_AUTOMATION_L10N_CHECK=0
+
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+. "$topsrcdir/build/mozconfig.common"
+
+# ld needs libLTO.so from llvm
+mk_add_options "export LD_LIBRARY_PATH=$topsrcdir/clang/lib"
+
+CROSS_CCTOOLS_PATH=$topsrcdir/cctools
+CROSS_SYSROOT=$topsrcdir/MacOSX10.7.sdk
+CROSS_PRIVATE_FRAMEWORKS=$CROSS_SYSROOT/System/Library/PrivateFrameworks
+FLAGS="-target x86_64-apple-darwin10 -mlinker-version=136 -B $CROSS_CCTOOLS_PATH/bin -isysroot $CROSS_SYSROOT"
+
+export CC="$topsrcdir/clang/bin/clang $FLAGS"
+export CXX="$topsrcdir/clang/bin/clang++ $FLAGS"
+export CPP="$topsrcdir/clang/bin/clang $FLAGS -E"
+export LLVMCONFIG=$topsrcdir/clang/bin/llvm-config
+export LDFLAGS="-Wl,-syslibroot,$CROSS_SYSROOT -Wl,-dead_strip"
+export TOOLCHAIN_PREFIX=$CROSS_CCTOOLS_PATH/bin/x86_64-apple-darwin10-
+export DSYMUTIL=$topsrcdir/clang/bin/llvm-dsymutil
+export GENISOIMAGE=$topsrcdir/genisoimage/genisoimage
+export DMG_TOOL=$topsrcdir/dmg/dmg
+
+export HOST_CC="$topsrcdir/clang/bin/clang"
+export HOST_CXX="$topsrcdir/clang/bin/clang++"
+export HOST_CPP="$topsrcdir/clang/bin/clang -E"
+export HOST_CFLAGS="-g"
+export HOST_CXXFLAGS="-g"
+export HOST_LDFLAGS="-g"
+
+ac_add_options --target=x86_64-apple-darwin
+ac_add_options --with-macos-private-frameworks=$CROSS_PRIVATE_FRAMEWORKS
+
+# Enable static analysis checks by default on OSX cross builds.
+ac_add_options --enable-clang-plugin
+
+. "$topsrcdir/build/mozconfig.cache"
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=/builds/crash-stats-api.token
diff --git a/build/macosx/local-mozconfig.common b/build/macosx/local-mozconfig.common
new file mode 100644
index 000000000..02a09d2fe
--- /dev/null
+++ b/build/macosx/local-mozconfig.common
@@ -0,0 +1,46 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPLOAD_SYMBOLS=${MOZ_AUTOMATION_UPLOAD_SYMBOLS-1}
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+. "$topsrcdir/build/mozconfig.common"
+
+if [ -d "$topsrcdir/clang" ]; then
+    # mozilla-central based build
+    export CC=$topsrcdir/clang/bin/clang
+    export CXX=$topsrcdir/clang/bin/clang++
+    export LLVMCONFIG=$topsrcdir/clang/bin/llvm-config
+    export DSYMUTIL=$topsrcdir/clang/bin/llvm-dsymutil
+    # Use an updated linker.
+    ldflags="-B$topsrcdir/cctools/bin"
+elif [ -d "$topsrcdir/../clang" ]; then
+    # comm-central based build
+    export CC=$topsrcdir/../clang/bin/clang
+    export CXX=$topsrcdir/../clang/bin/clang++
+    export LLVMCONFIG=$topsrcdir/../clang/bin/llvm-config
+    export DSYMUTIL=$topsrcdir/../clang/bin/llvm-dsymutil
+    # Use an updated linker.
+    ldflags="-B$topsrcdir/../cctools/bin"
+fi
+
+# Ensure the updated linker doesn't generate things our older build tools
+# don't understand.
+ldflags="$ldflags -Wl,-no_data_in_code_info"
+export LDFLAGS="$ldflags"
+
+# If not set use the system default clang
+if [ -z "$CC" ]; then
+    export CC=clang
+fi
+
+# If not set use the system default clang++
+if [ -z "$CXX" ]; then
+    export CXX=clang++
+fi
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=/builds/crash-stats-api.token
diff --git a/build/macosx/mozconfig.common b/build/macosx/mozconfig.common
new file mode 100644
index 000000000..27634b7f3
--- /dev/null
+++ b/build/macosx/mozconfig.common
@@ -0,0 +1,5 @@
+if test `uname -s` = Linux; then
+  . $topsrcdir/build/macosx/cross-mozconfig.common
+else
+  . $topsrcdir/build/macosx/local-mozconfig.common
+fi
diff --git a/build/macosx/universal/check-sync-exceptions b/build/macosx/universal/check-sync-exceptions
new file mode 100644
index 000000000..fc5149281
--- /dev/null
+++ b/build/macosx/universal/check-sync-exceptions
@@ -0,0 +1,9 @@
+flight.mk
+mozconfig.common
+
+# Ignore detritus left lying around by editing tools.
+*~
+.#*
+#*#
+*.orig
+*.rej
diff --git a/build/macosx/universal/flight.mk b/build/macosx/universal/flight.mk
new file mode 100644
index 000000000..2b79ef7ae
--- /dev/null
+++ b/build/macosx/universal/flight.mk
@@ -0,0 +1,33 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# BE CAREFUL!  This makefile handles a postflight_all rule for a
+# multi-project build, so DON'T rely on anything that might differ between
+# the two OBJDIRs.
+
+ifndef OBJDIR
+OBJDIR_ARCH_1 = $(MOZ_OBJDIR)/$(firstword $(MOZ_BUILD_PROJECTS))
+OBJDIR_ARCH_2 = $(MOZ_OBJDIR)/$(word 2,$(MOZ_BUILD_PROJECTS))
+DIST_ARCH_1 = $(OBJDIR_ARCH_1)/dist
+DIST_ARCH_2 = $(OBJDIR_ARCH_2)/dist
+DIST_UNI = $(DIST_ARCH_1)/universal
+OBJDIR = $(OBJDIR_ARCH_1)
+endif
+
+topsrcdir = $(TOPSRCDIR)
+DEPTH = $(OBJDIR)
+include $(OBJDIR)/config/autoconf.mk
+
+core_abspath = $(if $(filter /%,$(1)),$(1),$(CURDIR)/$(1))
+
+DIST = $(OBJDIR)/dist
+
+postflight_all:
+	mkdir -p $(DIST_UNI)/$(MOZ_PKG_APPNAME)
+	rm -f $(DIST_ARCH_2)/universal
+	ln -s $(abspath $(DIST_UNI)) $(DIST_ARCH_2)/universal
+# Stage a package for buildsymbols to be happy. Doing so in OBJDIR_ARCH_1
+# actually does a universal staging with both OBJDIR_ARCH_1 and OBJDIR_ARCH_2.
+	$(MAKE) -C $(OBJDIR_ARCH_1)/$(subst ../,,$(MOZ_BUILD_APP))/installer \
+	   PKG_SKIP_STRIP=1 stage-package
diff --git a/build/macosx/universal/mozconfig b/build/macosx/universal/mozconfig
new file mode 100644
index 000000000..32ab66f2d
--- /dev/null
+++ b/build/macosx/universal/mozconfig
@@ -0,0 +1,11 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# i386/x86-64 Universal Build mozconfig
+
+# As used here, arguments in $MOZ_BUILD_PROJECTS are suitable as arguments
+# to gcc's -arch parameter.
+mk_add_options MOZ_BUILD_PROJECTS="x86_64 i386"
+
+. $topsrcdir/build/macosx/universal/mozconfig.common
diff --git a/build/macosx/universal/mozconfig.common b/build/macosx/universal/mozconfig.common
new file mode 100644
index 000000000..518274b51
--- /dev/null
+++ b/build/macosx/universal/mozconfig.common
@@ -0,0 +1,54 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+mk_add_options MOZ_UNIFY_BDATE=1
+
+mk_add_options MOZ_POSTFLIGHT_ALL+=build/macosx/universal/flight.mk
+
+DARWIN_VERSION=`uname -r`
+ac_add_app_options i386 --target=i386-apple-darwin$DARWIN_VERSION
+ac_add_app_options x86_64 --target=x86_64-apple-darwin$DARWIN_VERSION
+ac_add_app_options i386 --with-unify-dist=../x86_64/dist
+ac_add_app_options x86_64 --with-unify-dist=../i386/dist
+
+ac_add_options --with-macos-sdk=/Developer/SDKs/MacOSX10.7.sdk
+
+. $topsrcdir/build/macosx/mozconfig.common
+
+# $MOZ_BUILD_APP is only defined when sourced by configure.  That's not a
+# problem, because the variables it affects only need to be set for
+# configure.
+if test -n "$MOZ_BUILD_APP" ; then
+if test "$MOZ_BUILD_APP" = "i386" -o "$MOZ_BUILD_APP" = "x86_64"; then
+  TARGET_CPU=$MOZ_BUILD_APP
+
+  # $HOST_CXX is presently unused.  $HOST_CC will only be used during a cross
+  # compile.
+  HOST_CC=$CC
+  HOST_CXX=$CXX
+
+  NATIVE_CPU=`$topsrcdir/build/autoconf/config.guess | cut -f1 -d-`
+
+  # It's not strictly necessary to specify -arch during native builds, but it
+  # makes the merged about:buildconfig easier to follow, and it reduces
+  # conditionalized differences between builds.
+  CC="$CC -arch $TARGET_CPU"
+  CXX="$CXX -arch $TARGET_CPU"
+
+  # These must be set for cross builds, and don't hurt straight builds.
+  RANLIB=ranlib
+  AR=ar
+  AS=$CC
+  LD=ld
+  STRIP="strip"
+  OTOOL="otool"
+
+  # Each per-CPU build should be entirely oblivious to the fact that a
+  # universal binary will be produced.  The exception is packager.mk, which
+  # needs to know to look for universal bits when building the .dmg.
+  UNIVERSAL_BINARY=1
+
+  export CC CXX HOST_CC HOST_CXX RANLIB AR AS LD STRIP OTOOL
+fi
+fi
diff --git a/build/merge-installrdf.py b/build/merge-installrdf.py
new file mode 100644
index 000000000..7a211c349
--- /dev/null
+++ b/build/merge-installrdf.py
@@ -0,0 +1,24 @@
+#!/usr/bin/python
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Get the target platform from a set of install.rdf files, and
+# return the first install.rdf with the platform replaced by the list of 
+# platforms as parsed from all the files
+# Allows to create a install.rdf for multiple platforms
+
+import sys
+from xml.dom.minidom import parse
+
+elems = []
+for arg in sys.argv[2:]:
+	doc = parse(arg + "/install.rdf")
+	elem = doc.getElementsByTagName("em:targetPlatform")[0]
+	elems.append(elem.cloneNode(True))
+
+doc = parse(sys.argv[1] + "/install.rdf")
+elem = doc.getElementsByTagName("em:targetPlatform")[0]
+for newelem in elems:
+	elem.parentNode.insertBefore(newelem, elem)
+print doc.toxml()
diff --git a/build/mozconfig.automation b/build/mozconfig.automation
new file mode 100644
index 000000000..057a4a0b5
--- /dev/null
+++ b/build/mozconfig.automation
@@ -0,0 +1,33 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Common mozconfig for automation builds.
+#
+# We export MOZ_AUTOMATION_* variables here to trigger various steps in
+# automation builds.  For example, if MOZ_AUTOMATION_PACKAGE is set, then the
+# package step will run.  This file contains the default settings, which can be
+# overridden by setting them earlier in the appropriate mozconfig.
+
+mk_add_options "export MOZ_AUTOMATION_BUILD_SYMBOLS=${MOZ_AUTOMATION_BUILD_SYMBOLS-1}"
+mk_add_options "export MOZ_AUTOMATION_L10N_CHECK=${MOZ_AUTOMATION_L10N_CHECK-1}"
+mk_add_options "export MOZ_AUTOMATION_PACKAGE=${MOZ_AUTOMATION_PACKAGE-1}"
+mk_add_options "export MOZ_AUTOMATION_PACKAGE_TESTS=${MOZ_AUTOMATION_PACKAGE_TESTS-1}"
+mk_add_options "export MOZ_AUTOMATION_INSTALLER=${MOZ_AUTOMATION_INSTALLER-0}"
+mk_add_options "export MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-0}"
+mk_add_options "export MOZ_AUTOMATION_UPLOAD=${MOZ_AUTOMATION_UPLOAD-1}"
+mk_add_options "export MOZ_AUTOMATION_UPLOAD_SYMBOLS=${MOZ_AUTOMATION_UPLOAD_SYMBOLS-0}"
+mk_add_options "export MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-0}"
+
+# If we are also building with MOZ_PKG_PRETTYNAMES, set the corresponding
+# stages.
+if test "$MOZ_AUTOMATION_PRETTY" = "1"; then
+    mk_add_options "export MOZ_AUTOMATION_PRETTY_PACKAGE=${MOZ_AUTOMATION_PACKAGE-1}"
+    mk_add_options "export MOZ_AUTOMATION_PRETTY_PACKAGE_TESTS=${MOZ_AUTOMATION_PACKAGE_TESTS-1}"
+    mk_add_options "export MOZ_AUTOMATION_PRETTY_L10N_CHECK=${MOZ_AUTOMATION_L10N_CHECK-1}"
+    mk_add_options "export MOZ_AUTOMATION_PRETTY_INSTALLER=${MOZ_AUTOMATION_INSTALLER-0}"
+
+    # Note that we always build the update packaging with pretty names even if
+    # we don't build it without, so this is set to 1.
+    mk_add_options "export MOZ_AUTOMATION_PRETTY_UPDATE_PACKAGING=1"
+fi
diff --git a/build/mozconfig.cache b/build/mozconfig.cache
new file mode 100644
index 000000000..be740e293
--- /dev/null
+++ b/build/mozconfig.cache
@@ -0,0 +1,135 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Setup for build cache
+
+# Avoid duplication if the file happens to be included twice.
+if test -z "$bucket" -a -z "$NO_CACHE"; then
+
+# buildbot (or builders that use buildprops.json):
+if [ -f $topsrcdir/../buildprops.json ]; then
+read branch platform master <<EOF
+$(python2.7 -c 'import json; p = json.loads(open("'"$topsrcdir"'/../buildprops.json").read())["properties"]; print p["branch"], p["platform"], p["master"]' 2> /dev/null)
+EOF
+
+bucket=
+if test -z "$SCCACHE_DISABLE" -a -z "$no_sccache" -a -z "$MOZ_PGO_IS_SET" -a -z "$MOZ_PGO"; then
+    case "${branch}" in
+    try)
+        case "${master}" in
+        *scl1.mozilla.com*|*.scl3.mozilla.com*)
+            bucket=mozilla-releng-s3-cache-us-west-1-try
+            ;;
+        *use1.mozilla.com*)
+            bucket=mozilla-releng-s3-cache-us-east-1-try
+            ;;
+        *usw2.mozilla.com*)
+            bucket=mozilla-releng-s3-cache-us-west-2-try
+            ;;
+        esac
+        ;;
+    autoland|mozilla-inbound)
+        case "${master}" in
+        *use1.mozilla.com*)
+            bucket=mozilla-releng-s3-cache-us-east-1-prod
+            ;;
+        *usw2.mozilla.com*)
+            bucket=mozilla-releng-s3-cache-us-west-2-prod
+            ;;
+        esac
+        ;;
+    esac
+fi
+
+# builds without buildprops (eg: taskcluster or non-buildbot) and without ccache env config and without sccache disabled:
+elif test -z "$CCACHE_DIR" -a -z "$SCCACHE_DISABLE" -a -z "$no_sccache" -a -z "$MOZ_PGO_IS_SET" -a -z "$MOZ_PGO"; then
+
+    # prevent rerun if az is set, or wget is not available
+    if test -z "$availability_zone" -a -x "$(command -v wget)"; then
+        # timeout after 1 second, and don't retry (failure indicates instance is not in ec2 or network issue)
+        # availability_zone is of the form <region><letter> where region is e.g. us-west-2, and az is us-west-2a
+        availability_zone=$(wget -T 1 -t 1 -q -O - http://169.254.169.254/latest/meta-data/placement/availability-zone || true)
+        if test -z "$availability_zone" -o "$availability_zone" = "not-ec2"; then
+            availability_zone=not-ec2
+        else
+            # region is az with last letter trimmed
+            region=${availability_zone%?}
+            # set S3 bucket according to tree (level)
+            case "${GECKO_HEAD_REPOSITORY}" in
+            *hg.mozilla.org/try*)
+                bucket=taskcluster-level-1-sccache-${region}
+                ;;
+            *hg.mozilla.org/integration/autoland*|*hg.mozilla.org/integration/mozilla-inbound*)
+                bucket=taskcluster-level-3-sccache-${region}
+                ;;
+            esac
+
+            # set a dummy master
+            case "${region}" in
+            eu-central-1)
+                master=dummy.euc1.mozilla.com
+                ;;
+            us-east-1)
+                master=dummy.use1.mozilla.com
+                ;;
+            us-west-1)
+                master=dummy.usw1.mozilla.com
+                ;;
+            us-west-2)
+                master=dummy.usw2.mozilla.com
+                ;;
+            esac
+        fi
+    fi
+fi
+
+# if platform hasn't been determined from buildprops, and we're on windows,
+# it must be set to prevent adding ac_add_options --with-ccache below
+if test -z "$platform"; then
+    # set platform based on the SYSTEMROOT env var
+    case "${SYSTEMROOT}" in
+    *Windows)
+        platform=windows
+        ;;
+    esac
+fi
+
+if test -z "$bucket"; then
+    case "$platform" in
+    win*) : ;;
+    *)
+        ac_add_options --with-ccache
+    esac
+else
+    if ! test -e $topsrcdir/sccache/sccache.py; then
+        echo "Sccache missing in the tooltool manifest" >&2
+        exit 1
+    fi
+    mk_add_options "export SCCACHE_BUCKET=$bucket"
+    case "$master" in
+    *us[ew][12].mozilla.com*|*euc1.mozilla.com*)
+        mk_add_options "export SCCACHE_NAMESERVER=169.254.169.253"
+        ;;
+    esac
+    ac_add_options "--with-compiler-wrapper=python2.7 $topsrcdir/sccache/sccache.py"
+    mk_add_options MOZ_PREFLIGHT_ALL+=build/sccache.mk
+    mk_add_options MOZ_POSTFLIGHT_ALL+=build/sccache.mk
+    mk_add_options "UPLOAD_EXTRA_FILES+=sccache.log.gz"
+    case "$platform" in
+    win*)
+        # sccache supports a special flag to create depfiles.
+        export _DEPEND_CFLAGS='-deps$(MDDEPDIR)/$(@F).pp'
+        # Windows builds have a default wrapper that needs to be overridden
+        mk_add_options "export CC_WRAPPER="
+        mk_add_options "export CXX_WRAPPER="
+        # For now, sccache doesn't support separate PDBs so force debug info to be
+        # in object files.
+        mk_add_options "export COMPILE_PDB_FLAG="
+        mk_add_options "export HOST_PDB_FLAG="
+        mk_add_options "export MOZ_DEBUG_FLAGS=-Z7"
+        ;;
+    esac
+fi
+
+fi
diff --git a/build/mozconfig.common b/build/mozconfig.common
new file mode 100644
index 000000000..3d2d0b289
--- /dev/null
+++ b/build/mozconfig.common
@@ -0,0 +1,26 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Common mozconfig for official builds.
+#
+# Add options to this file that will be inherited by all in-tree mozconfigs.
+# This is useful for eg try builds with nondefault options that apply to all
+# architectures, though note that if you want to override options set in
+# another mozconfig file, you'll need to use mozconfig.common.override instead
+# of this file.
+
+mk_add_options AUTOCLOBBER=1
+
+ac_add_options --enable-crashreporter
+
+ac_add_options --enable-release
+
+# Disable checking that add-ons are signed by the trusted root
+MOZ_ADDON_SIGNING=${MOZ_ADDON_SIGNING-0}
+# Disable enforcing that add-ons are signed by the trusted root
+MOZ_REQUIRE_SIGNING=${MOZ_REQUIRE_SIGNING-0}
+
+ac_add_options --enable-js-shell
+
+. "$topsrcdir/build/mozconfig.automation"
diff --git a/build/mozconfig.rust b/build/mozconfig.rust
new file mode 100644
index 000000000..65177a6bd
--- /dev/null
+++ b/build/mozconfig.rust
@@ -0,0 +1,10 @@
+# Options to enable rust in automation builds.
+
+# Tell configure to use the tooltool rustc.
+# Assume this is compiled with --enable-rpath so we don't
+# have to set LD_LIBRARY_PATH.
+RUSTC="$topsrcdir/rustc/bin/rustc"
+CARGO="$topsrcdir/cargo/bin/cargo"
+
+# Enable rust in the build.
+ac_add_options --enable-rust
diff --git a/build/mozconfig.vs-common b/build/mozconfig.vs-common
new file mode 100644
index 000000000..ca5df2f3a
--- /dev/null
+++ b/build/mozconfig.vs-common
@@ -0,0 +1,4 @@
+# Pymake needs Windows-style paths. Use cmd.exe to hack around this.

+mk_export_correct_style() {

+  mk_add_options "export $1=$(cmd.exe //c echo %$1%)"

+}

diff --git a/build/mozconfig.win-common b/build/mozconfig.win-common
new file mode 100644
index 000000000..6e25b7ce4
--- /dev/null
+++ b/build/mozconfig.win-common
@@ -0,0 +1,16 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPLOAD_SYMBOLS=${MOZ_AUTOMATION_UPLOAD_SYMBOLS-1}
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+
+# Some builds (eg: Mulet) don't want the installer, so only set this if it
+# hasn't already been set.
+MOZ_AUTOMATION_INSTALLER=${MOZ_AUTOMATION_INSTALLER-1}
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=c:/builds/crash-stats-api.token
diff --git a/build/pymake/make.py b/build/pymake/make.py
new file mode 100644
index 000000000..178bdd747
--- /dev/null
+++ b/build/pymake/make.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# This is a wrapper around mozilla-central's pymake. If that isn't found then
+# this uses client.py to pull it in.
+
+import os
+import sys
+import subprocess
+import shlex
+
+def getpath(relpath):
+    thisdir = os.path.dirname(__file__)
+    return os.path.abspath(os.path.join(thisdir, *relpath))
+
+PYMAKE = getpath(["..", "..", "mozilla", "build", "pymake", "make.py"])
+CLIENT_PY = getpath(["..", "..", "client.py"])
+CLIENT_PY_ARGS = getpath(["..", "client.py-args"])
+
+def main(args):
+    if 'TINDERBOX_OUTPUT' in os.environ:
+        # When building on mozilla build slaves, execute mozmake instead. Until bug
+        # 978211, this is the easiest, albeit hackish, way to do this.
+        mozmake = os.path.join(os.path.dirname(__file__), '..', '..',
+            'mozmake.exe')
+        if os.path.exists(mozmake):
+            cmd = [mozmake]
+            cmd.extend(sys.argv[1:])
+            shell = os.environ.get('SHELL')
+            if shell and not shell.lower().endswith('.exe'):
+                cmd += ['SHELL=%s.exe' % shell]
+            sys.exit(subprocess.call(cmd))
+
+    if not os.path.exists(PYMAKE):
+        clientpyargs = open(CLIENT_PY_ARGS, "r").read().strip()
+        clientpyargs = shlex.split(clientpyargs)
+        subprocess.check_call([sys.executable, CLIENT_PY, "checkout"] +
+                              clientpyargs)
+
+        if not os.path.exists(PYMAKE):
+            raise Exception("Pymake not found even after client.py was run")
+
+    subprocess.check_call([sys.executable, PYMAKE] + args)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/build/pypng/check-sync-exceptions b/build/pypng/check-sync-exceptions
new file mode 100644
index 000000000..b326f7c3b
--- /dev/null
+++ b/build/pypng/check-sync-exceptions
@@ -0,0 +1,3 @@
+# Nothing in this directory needs to be in sync with mozilla
+# The contents are used only in c-c
+*
\ No newline at end of file
diff --git a/build/pypng/exnumpy.py b/build/pypng/exnumpy.py
new file mode 100644
index 000000000..82daf0a60
--- /dev/null
+++ b/build/pypng/exnumpy.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/exnumpy.py $
+# $Rev: 126 $
+
+# Numpy example.
+# Original code created by Mel Raab, modified by David Jones.
+
+'''
+  Example code integrating RGB PNG files, PyPNG and NumPy
+  (abstracted from Mel Raab's functioning code)
+'''
+
+# http://www.python.org/doc/2.4.4/lib/module-itertools.html
+import itertools
+
+import numpy
+import png
+
+
+''' If you have a PNG file for an RGB image,
+    and want to create a numpy array of data from it.
+'''
+# Read the file "picture.png" from the current directory.  The `Reader`
+# class can take a filename, a file-like object, or the byte data
+# directly; this suggests alternatives such as using urllib to read
+# an image from the internet:
+# png.Reader(file=urllib.urlopen('http://www.libpng.org/pub/png/PngSuite/basn2c16.png'))
+pngReader=png.Reader(filename='picture.png')
+# Tuple unpacking, using multiple assignment, is very useful for the
+# result of asDirect (and other methods).
+# See
+# http://docs.python.org/tutorial/introduction.html#first-steps-towards-programming
+row_count, column_count, pngdata, meta = pngReader.asDirect()
+bitdepth=meta['bitdepth']
+plane_count=meta['planes']
+
+# Make sure we're dealing with RGB files
+assert plane_count == 3
+
+''' Boxed row flat pixel:
+      list([R,G,B, R,G,B, R,G,B],
+           [R,G,B, R,G,B, R,G,B])
+    Array dimensions for this example:  (2,9)
+
+    Create `image_2d` as a two-dimensional NumPy array by stacking a
+    sequence of 1-dimensional arrays (rows).
+    The NumPy array mimics PyPNG's (boxed row flat pixel) representation;
+    it will have dimensions ``(row_count,column_count*plane_count)``.
+'''
+# The use of ``numpy.uint16``, below, is to convert each row to a NumPy
+# array with data type ``numpy.uint16``.  This is a feature of NumPy,
+# discussed further in 
+# http://docs.scipy.org/doc/numpy/user/basics.types.html .
+# You can use avoid the explicit conversion with
+# ``numpy.vstack(pngdata)``, but then NumPy will pick the array's data
+# type; in practice it seems to pick ``numpy.int32``, which is large enough
+# to hold any pixel value for any PNG image but uses 4 bytes per value when
+# 1 or 2 would be enough.
+# --- extract 001 start
+image_2d = numpy.vstack(itertools.imap(numpy.uint16, pngdata))
+# --- extract 001 end
+# Do not be tempted to use ``numpy.asarray``; when passed an iterator
+# (`pngdata` is often an iterator) it will attempt to create a size 1
+# array with the iterator as its only element.
+# An alternative to the above is to create the target array of the right
+# shape, then populate it row by row:
+if 0:
+    image_2d = numpy.zeros((row_count,plane_count*column_count),
+                           dtype=numpy.uint16)
+    for row_index, one_boxed_row_flat_pixels in enumerate(pngdata):
+        image_2d[row_index,:]=one_boxed_row_flat_pixels
+
+del pngReader
+del pngdata
+
+
+''' Reconfigure for easier referencing, similar to
+        Boxed row boxed pixel:
+            list([ (R,G,B), (R,G,B), (R,G,B) ],
+                 [ (R,G,B), (R,G,B), (R,G,B) ])
+    Array dimensions for this example:  (2,3,3)
+
+    ``image_3d`` will contain the image as a three-dimensional numpy
+    array, having dimensions ``(row_count,column_count,plane_count)``.
+'''
+# --- extract 002 start
+image_3d = numpy.reshape(image_2d,
+                         (row_count,column_count,plane_count))
+# --- extract 002 end
+
+
+''' ============= '''
+
+''' Convert NumPy image_3d array to PNG image file.
+
+    If the data is three-dimensional, as it is above, the best thing
+    to do is reshape it into a two-dimensional array with a shape of
+    ``(row_count, column_count*plane_count)``.  Because a
+    two-dimensional numpy array is an iterator, it can be passed
+    directly to the ``png.Writer.write`` method.
+'''
+
+row_count, column_count, plane_count = image_3d.shape
+assert plane_count==3
+
+pngfile = open('picture_out.png', 'wb')
+try:
+    # This example assumes that you have 16-bit pixel values in the data
+    # array (that's what the ``bitdepth=16`` argument is for).
+    # If you don't, then the resulting PNG file will likely be
+    # very dark.  Hey, it's only an example.
+    pngWriter = png.Writer(column_count, row_count,
+                           greyscale=False,
+                           alpha=False,
+                           bitdepth=16)
+    # As of 2009-04-13 passing a numpy array that has an element type
+    # that is a numpy integer type (for example, the `image_3d` array has an
+    # element type of ``numpy.uint16``) generates a deprecation warning.
+    # This is probably a bug in numpy; it may go away in the future.
+    # The code still works despite the warning.
+    # See http://code.google.com/p/pypng/issues/detail?id=44
+# --- extract 003 start
+    pngWriter.write(pngfile,
+                    numpy.reshape(image_3d, (-1, column_count*plane_count)))
+# --- extract 003 end
+finally:
+    pngfile.close()
+
diff --git a/build/pypng/iccp.py b/build/pypng/iccp.py
new file mode 100644
index 000000000..190db734c
--- /dev/null
+++ b/build/pypng/iccp.py
@@ -0,0 +1,537 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/iccp.py $
+# $Rev: 182 $
+
+# iccp
+#
+# International Color Consortium Profile
+#
+# Tools for manipulating ICC profiles.
+#
+# An ICC profile can be extracted from a PNG image (iCCP chunk).
+#
+#
+# Non-standard ICCP tags.
+#
+# Apple use some (widespread but) non-standard tags.  These can be
+# displayed in Apple's ColorSync Utility.
+# - 'vcgt' (Video Card Gamma Tag).  Table to load into video
+#    card LUT to apply gamma.
+# - 'ndin' Apple display native information.
+# - 'dscm' Apple multi-localized description strings.
+# - 'mmod' Apple display make and model information.
+# 
+
+# References
+#
+# [ICC 2001] ICC Specification ICC.1:2001-04 (Profile version 2.4.0)
+# [ICC 2004] ICC Specification ICC.1:2004-10 (Profile version 4.2.0.0)
+
+import struct
+
+import png
+
+class FormatError(Exception):
+    pass
+
+class Profile:
+    """An International Color Consortium Profile (ICC Profile)."""
+
+    def __init__(self):
+        self.rawtagtable = None
+        self.rawtagdict = {}
+        self.d = dict()
+
+    def fromFile(self, inp, name='<unknown>'):
+
+        # See [ICC 2004]
+        profile = inp.read(128)
+        if len(profile) < 128:
+            raise FormatError("ICC Profile is too short.")
+        size, = struct.unpack('>L', profile[:4])
+        profile += inp.read(d['size'] - len(profile))
+        return self.fromString(profile, name)
+
+    def fromString(self, profile, name='<unknown>'):
+        self.d = dict()
+        d = self.d
+        if len(profile) < 128:
+            raise FormatError("ICC Profile is too short.")
+        d.update(
+          zip(['size', 'preferredCMM', 'version',
+               'profileclass', 'colourspace', 'pcs'],
+              struct.unpack('>L4sL4s4s4s', profile[:24])))
+        if len(profile) < d['size']:
+            warnings.warn(
+              'Profile size declared to be %d, but only got %d bytes' %
+                (d['size'], len(profile)))
+        d['version'] = '%08x' % d['version']
+        d['created'] = readICCdatetime(profile[24:36])
+        d.update(
+          zip(['acsp', 'platform', 'flag', 'manufacturer', 'model'],
+              struct.unpack('>4s4s3L', profile[36:56])))
+        if d['acsp'] != 'acsp':
+            warnings.warn('acsp field not present (not an ICC Profile?).')
+        d['deviceattributes'] = profile[56:64]
+        d['intent'], = struct.unpack('>L', profile[64:68])
+        d['pcsilluminant'] = readICCXYZNumber(profile[68:80])
+        d['creator'] = profile[80:84]
+        d['id'] = profile[84:100]
+        ntags, = struct.unpack('>L', profile[128:132])
+        d['ntags'] = ntags
+        fmt = '4s2L' * ntags
+        # tag table
+        tt = struct.unpack('>' + fmt, profile[132:132+12*ntags])
+        tt = group(tt, 3)
+
+        # Could (should) detect 2 or more tags having the same sig.  But
+        # we don't.  Two or more tags with the same sig is illegal per
+        # the ICC spec.
+        
+        # Convert (sig,offset,size) triples into (sig,value) pairs.
+        rawtag = map(lambda x: (x[0], profile[x[1]:x[1]+x[2]]), tt)
+        self.rawtagtable = rawtag
+        self.rawtagdict = dict(rawtag)
+        tag = dict()
+        # Interpret the tags whose types we know about
+        for sig, v in rawtag:
+            if sig in tag:
+                warnings.warn("Duplicate tag %r found.  Ignoring." % sig)
+                continue
+            v = ICCdecode(v)
+            if v is not None:
+                tag[sig] = v
+        self.tag = tag
+        return self
+
+    def greyInput(self):
+        """Adjust ``self.d`` dictionary for greyscale input device.
+        ``profileclass`` is 'scnr', ``colourspace`` is 'GRAY', ``pcs``
+        is 'XYZ '.
+        """
+
+        self.d.update(dict(profileclass='scnr',
+          colourspace='GRAY', pcs='XYZ '))
+        return self
+
+    def maybeAddDefaults(self):
+        if self.rawtagdict:
+            return
+        self._addTags(
+          cprt='Copyright unknown.',
+          desc='created by $URL: http://pypng.googlecode.com/svn/trunk/code/iccp.py $ $Rev: 182 $',
+          wtpt=D50(),
+          )
+
+    def addTags(self, **k):
+        self.maybeAddDefaults()
+        self._addTags(**k)
+
+    def _addTags(self, **k):
+        """Helper for :meth:`addTags`."""
+
+        for tag, thing in k.items():
+            if not isinstance(thing, (tuple, list)):
+                thing = (thing,)
+            typetag = defaulttagtype[tag]
+            self.rawtagdict[tag] = encode(typetag, *thing)
+        return self
+
+    def write(self, out):
+        """Write ICC Profile to the file."""
+
+        if not self.rawtagtable:
+            self.rawtagtable = self.rawtagdict.items()
+        tags = tagblock(self.rawtagtable)
+        self.writeHeader(out, 128 + len(tags))
+        out.write(tags)
+        out.flush()
+
+        return self
+
+    def writeHeader(self, out, size=999):
+        """Add default values to the instance's `d` dictionary, then
+        write a header out onto the file stream.  The size of the
+        profile must be specified using the `size` argument.
+        """
+
+        def defaultkey(d, key, value):
+            """Add ``[key]==value`` to the dictionary `d`, but only if
+            it does not have that key already.
+            """
+
+            if key in d:
+                return
+            d[key] = value
+
+        z = '\x00' * 4
+        defaults = dict(preferredCMM=z,
+                        version='02000000',
+                        profileclass=z,
+                        colourspace=z,
+                        pcs='XYZ ',
+                        created=writeICCdatetime(),
+                        acsp='acsp',
+                        platform=z,
+                        flag=0,
+                        manufacturer=z,
+                        model=0,
+                        deviceattributes=0,
+                        intent=0,
+                        pcsilluminant=encodefuns()['XYZ'](*D50()),
+                        creator=z,
+                        )
+        for k,v in defaults.items():
+            defaultkey(self.d, k, v)
+
+        hl = map(self.d.__getitem__,
+                 ['preferredCMM', 'version', 'profileclass', 'colourspace',
+                  'pcs', 'created', 'acsp', 'platform', 'flag',
+                  'manufacturer', 'model', 'deviceattributes', 'intent',
+                  'pcsilluminant', 'creator'])
+        # Convert to struct.pack input
+        hl[1] = int(hl[1], 16)
+
+        out.write(struct.pack('>L4sL4s4s4s12s4s4sL4sLQL12s4s', size, *hl))
+        out.write('\x00' * 44)
+        return self
+
+def encodefuns():
+    """Returns a dictionary mapping ICC type signature sig to encoding
+    function.  Each function returns a string comprising the content of
+    the encoded value.  To form the full value, the type sig and the 4
+    zero bytes should be prefixed (8 bytes).
+    """
+
+    def desc(ascii):
+        """Return textDescription type [ICC 2001] 6.5.17.  The ASCII part is
+        filled in with the string `ascii`, the Unicode and ScriptCode parts
+        are empty."""
+
+        ascii += '\x00'
+        l = len(ascii)
+
+        return struct.pack('>L%ds2LHB67s' % l,
+                           l, ascii, 0, 0, 0, 0, '')
+
+    def text(ascii):
+        """Return textType [ICC 2001] 6.5.18."""
+
+        return ascii + '\x00'
+
+    def curv(f=None, n=256):
+        """Return a curveType, [ICC 2001] 6.5.3.  If no arguments are
+        supplied then a TRC for a linear response is generated (no entries).
+        If an argument is supplied and it is a number (for *f* to be a
+        number it  means that ``float(f)==f``) then a TRC for that
+        gamma value is generated.
+        Otherwise `f` is assumed to be a function that maps [0.0, 1.0] to
+        [0.0, 1.0]; an `n` element table is generated for it.
+        """
+
+        if f is None:
+            return struct.pack('>L',  0)
+        try:
+            if float(f) == f:
+                return struct.pack('>LH', 1, int(round(f*2**8)))
+        except (TypeError, ValueError):
+            pass
+        assert n >= 2
+        table = []
+        M = float(n-1)
+        for i in range(n):
+            x = i/M
+            table.append(int(round(f(x) * 65535)))
+        return struct.pack('>L%dH' % n, n, *table)
+
+    def XYZ(*l):
+        return struct.pack('>3l', *map(fs15f16, l))
+
+    return locals()
+
+# Tag type defaults.
+# Most tags can only have one or a few tag types.
+# When encoding, we associate a default tag type with each tag so that
+# the encoding is implicit.
+defaulttagtype=dict(
+  A2B0='mft1',
+  A2B1='mft1',
+  A2B2='mft1',
+  bXYZ='XYZ',
+  bTRC='curv',
+  B2A0='mft1',
+  B2A1='mft1',
+  B2A2='mft1',
+  calt='dtim',
+  targ='text',
+  chad='sf32',
+  chrm='chrm',
+  cprt='desc',
+  crdi='crdi',
+  dmnd='desc',
+  dmdd='desc',
+  devs='',
+  gamt='mft1',
+  kTRC='curv',
+  gXYZ='XYZ',
+  gTRC='curv',
+  lumi='XYZ',
+  meas='',
+  bkpt='XYZ',
+  wtpt='XYZ',
+  ncol='',
+  ncl2='',
+  resp='',
+  pre0='mft1',
+  pre1='mft1',
+  pre2='mft1',
+  desc='desc',
+  pseq='',
+  psd0='data',
+  psd1='data',
+  psd2='data',
+  psd3='data',
+  ps2s='data',
+  ps2i='data',
+  rXYZ='XYZ',
+  rTRC='curv',
+  scrd='desc',
+  scrn='',
+  tech='sig',
+  bfd='',
+  vued='desc',
+  view='view',
+)
+
+def encode(tsig, *l):
+    """Encode a Python value as an ICC type.  `tsig` is the type
+    signature to (the first 4 bytes of the encoded value, see [ICC 2004]
+    section 10.
+    """
+
+    fun = encodefuns()
+    if tsig not in fun:
+        raise "No encoder for type %r." % tsig
+    v = fun[tsig](*l)
+    # Padd tsig out with spaces.
+    tsig = (tsig + '   ')[:4]
+    return tsig + '\x00'*4 + v
+
+def tagblock(tag):
+    """`tag` should be a list of (*signature*, *element*) pairs, where
+    *signature* (the key) is a length 4 string, and *element* is the
+    content of the tag element (another string).
+    
+    The entire tag block (consisting of first a table and then the
+    element data) is constructed and returned as a string.
+    """
+
+    n = len(tag)
+    tablelen = 12*n
+
+    # Build the tag table in two parts.  A list of 12-byte tags, and a
+    # string of element data.  Offset is the offset from the start of
+    # the profile to the start of the element data (so the offset for
+    # the next element is this offset plus the length of the element
+    # string so far).
+    offset = 128 + tablelen + 4
+    # The table.  As a string.
+    table = ''
+    # The element data
+    element = ''
+    for k,v in tag:
+        table += struct.pack('>4s2L', k, offset + len(element), len(v))
+        element += v
+    return struct.pack('>L', n) + table + element
+
+def iccp(out, inp):
+    profile = Profile().fromString(*profileFromPNG(inp))
+    print >>out, profile.d
+    print >>out, map(lambda x: x[0], profile.rawtagtable)
+    print >>out, profile.tag
+
+def profileFromPNG(inp):
+    """Extract profile from PNG file.  Return (*profile*, *name*)
+    pair."""
+    r = png.Reader(file=inp)
+    _,chunk = r.chunk('iCCP')
+    i = chunk.index('\x00')
+    name = chunk[:i]
+    compression = chunk[i+1]
+    assert compression == chr(0)
+    profile = chunk[i+2:].decode('zlib')
+    return profile, name
+
+def iccpout(out, inp):
+    """Extract ICC Profile from PNG file `inp` and write it to
+    the file `out`."""
+
+    out.write(profileFromPNG(inp)[0])
+
+def fs15f16(x):
+    """Convert float to ICC s15Fixed16Number (as a Python ``int``)."""
+
+    return int(round(x * 2**16))
+
+def D50():
+    """Return D50 illuminant as an (X,Y,Z) triple."""
+
+    # See [ICC 2001] A.1
+    return (0.9642, 1.0000, 0.8249)
+
+
+def writeICCdatetime(t=None):
+    """`t` should be a gmtime tuple (as returned from
+    ``time.gmtime()``).  If not supplied, the current time will be used.
+    Return an ICC dateTimeNumber in a 12 byte string.
+    """
+
+    import time
+    if t is None:
+        t = time.gmtime()
+    return struct.pack('>6H', *t[:6])
+
+def readICCdatetime(s):
+    """Convert from 12 byte ICC representation of dateTimeNumber to
+    ISO8601 string. See [ICC 2004] 5.1.1"""
+
+    return '%04d-%02d-%02dT%02d:%02d:%02dZ' % struct.unpack('>6H', s)
+
+def readICCXYZNumber(s):
+    """Convert from 12 byte ICC representation of XYZNumber to (x,y,z)
+    triple of floats.  See [ICC 2004] 5.1.11"""
+
+    return s15f16l(s)
+
+def s15f16l(s):
+    """Convert sequence of ICC s15Fixed16 to list of float."""
+    # Note: As long as float has at least 32 bits of mantissa, all
+    # values are preserved.
+    n = len(s)//4
+    t = struct.unpack('>%dl' % n, s)
+    return map((2**-16).__mul__, t)
+
+# Several types and their byte encodings are defined by [ICC 2004]
+# section 10.  When encoded, a value begins with a 4 byte type
+# signature.  We use the same 4 byte type signature in the names of the
+# Python functions that decode the type into a Pythonic representation.
+
+def ICCdecode(s):
+    """Take an ICC encoded tag, and dispatch on its type signature
+    (first 4 bytes) to decode it into a Python value.  Pair (*sig*,
+    *value*) is returned, where *sig* is a 4 byte string, and *value* is
+    some Python value determined by the content and type.
+    """
+
+    sig = s[0:4].strip()
+    f=dict(text=RDtext,
+           XYZ=RDXYZ,
+           curv=RDcurv,
+           vcgt=RDvcgt,
+           sf32=RDsf32,
+           )
+    if sig not in f:
+        return None
+    return (sig, f[sig](s))
+
+def RDXYZ(s):
+    """Convert ICC XYZType to rank 1 array of trimulus values."""
+
+    # See [ICC 2001] 6.5.26
+    assert s[0:4] == 'XYZ '
+    return readICCXYZNumber(s[8:])
+
+def RDsf32(s):
+    """Convert ICC s15Fixed16ArrayType to list of float."""
+    # See [ICC 2004] 10.18
+    assert s[0:4] == 'sf32'
+    return s15f16l(s[8:])
+
+def RDmluc(s):
+    """Convert ICC multiLocalizedUnicodeType.  This types encodes
+    several strings together with a language/country code for each
+    string.  A list of (*lc*, *string*) pairs is returned where *lc* is
+    the 4 byte language/country code, and *string* is the string
+    corresponding to that code.  It seems unlikely that the same
+    language/country code will appear more than once with different
+    strings, but the ICC standard does not prohibit it."""
+    # See [ICC 2004] 10.13
+    assert s[0:4] == 'mluc'
+    n,sz = struct.unpack('>2L', s[8:16])
+    assert sz == 12
+    record = []
+    for i in range(n):
+        lc,l,o = struct.unpack('4s2L', s[16+12*n:28+12*n])
+        record.append(lc, s[o:o+l])
+    # How are strings encoded?
+    return record
+
+def RDtext(s):
+    """Convert ICC textType to Python string."""
+    # Note: type not specified or used in [ICC 2004], only in older
+    # [ICC 2001].
+    # See [ICC 2001] 6.5.18
+    assert s[0:4] == 'text'
+    return s[8:-1]
+
+def RDcurv(s):
+    """Convert ICC curveType."""
+    # See [ICC 2001] 6.5.3
+    assert s[0:4] == 'curv'
+    count, = struct.unpack('>L', s[8:12])
+    if count == 0:
+        return dict(gamma=1)
+    table = struct.unpack('>%dH' % count, s[12:])
+    if count == 1:
+        return dict(gamma=table[0]*2**-8)
+    return table
+
+def RDvcgt(s):
+    """Convert Apple CMVideoCardGammaType."""
+    # See
+    # http://developer.apple.com/documentation/GraphicsImaging/Reference/ColorSync_Manager/Reference/reference.html#//apple_ref/c/tdef/CMVideoCardGammaType
+    assert s[0:4] == 'vcgt'
+    tagtype, = struct.unpack('>L', s[8:12])
+    if tagtype != 0:
+        return s[8:]
+    if tagtype == 0:
+        # Table.
+        channels,count,size = struct.unpack('>3H', s[12:18])
+        if size == 1:
+            fmt = 'B'
+        elif size == 2:
+            fmt = 'H'
+        else:
+            return s[8:]
+        l = len(s[18:])//size
+        t = struct.unpack('>%d%s' % (l, fmt), s[18:])
+        t = group(t, count)
+        return size, t
+    return s[8:]
+
+
+def group(s, n):
+    # See
+    # http://www.python.org/doc/2.6/library/functions.html#zip
+    return zip(*[iter(s)]*n)
+
+
+def main(argv=None):
+    import sys
+    from getopt import getopt
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+    opt,arg = getopt(argv, 'o:')
+    if len(arg) > 0:
+        inp = open(arg[0], 'rb')
+    else:
+        inp = sys.stdin
+    for o,v in opt:
+        if o == '-o':
+            f = open(v, 'wb')
+            return iccpout(f, inp)
+    return iccp(sys.stdout, inp)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/mkiccp.py b/build/pypng/mkiccp.py
new file mode 100644
index 000000000..08e8df63a
--- /dev/null
+++ b/build/pypng/mkiccp.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/mkiccp.py $
+# $Rev: 182 $
+# Make ICC Profile
+
+# References
+#
+# [ICC 2001] ICC Specification ICC.1:2001-04 (Profile version 2.4.0)
+# [ICC 2004] ICC Specification ICC.1:2004-10 (Profile version 4.2.0.0)
+
+import struct
+
+# Local module.
+import iccp
+
+def black(m):
+    """Return a function that maps all values from [0.0,m] to 0, and maps
+    the range [m,1.0] into [0.0, 1.0] linearly.
+    """
+
+    m = float(m)
+
+    def f(x):
+        if x <= m:
+            return 0.0
+        return (x-m)/(1.0-m)
+    return f
+
+# For monochrome input the required tags are (See [ICC 2001] 6.3.1.1):
+# profileDescription [ICC 2001] 6.4.32
+# grayTRC [ICC 2001] 6.4.19
+# mediaWhitePoint [ICC 2001] 6.4.25
+# copyright [ICC 2001] 6.4.13
+
+def agreyprofile(out):
+    it = iccp.Profile().greyInput()
+    it.addTags(kTRC=black(0.07))
+    it.write(out)
+
+def main():
+    import sys
+    agreyprofile(sys.stdout)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pdsimgtopng b/build/pypng/pdsimgtopng
new file mode 100644
index 000000000..975db930a
--- /dev/null
+++ b/build/pypng/pdsimgtopng
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pdsimgtopng $
+# $Rev: 154 $
+# PDS Image to PNG
+
+import re
+import struct
+
+import png
+
+class FormatError(Exception):
+    pass
+
+def pdskey(s, k):
+    """Lookup key `k` in string `s`.  Returns value (as a string), or
+    raises exception if not found.
+    """
+
+    assert re.match(r' *\^?[:\w]+$', k)
+    safere = '^' + re.escape(k) +r' *= *(\w+)'
+    m = re.search(safere, s, re.MULTILINE)
+    if not m:
+        raise FormatError("Can't find %s." % k)
+    return m.group(1)
+
+def img(inp):
+    """Open the PDS IMG file `inp` and return (*pixels*, *info*).
+    *pixels* is an iterator over the rows, *info* is the information
+    dictionary.
+    """
+
+    err = __import__('sys').stderr
+
+    consumed = 1024
+
+    s = inp.read(consumed)
+    record_type = pdskey(s, 'RECORD_TYPE')
+    if record_type != 'FIXED_LENGTH':
+        raise FormatError(
+          "Can only deal with FIXED_LENGTH record type (found %s)" %
+            record_type)
+    record_bytes = int(pdskey(s,'RECORD_BYTES'))
+    file_records = int(pdskey(s, 'FILE_RECORDS'))
+    label_records = int(pdskey(s, 'LABEL_RECORDS'))
+    remaining = label_records * record_bytes - consumed
+    s += inp.read(remaining)
+    consumed += remaining
+
+    image_pointer = int(pdskey(s, '^IMAGE'))
+    # "^IMAGE" locates a record.  Records are numbered starting from 1.
+    image_index = image_pointer - 1
+    image_offset = image_index * record_bytes
+    gap = image_offset - consumed
+    assert gap >= 0
+    if gap:
+        inp.read(gap)
+    # This assumes there is only one OBJECT in the file, and it is the
+    # IMAGE.
+    height = int(pdskey(s, '  LINES'))
+    width = int(pdskey(s, '  LINE_SAMPLES'))
+    sample_type = pdskey(s, '  SAMPLE_TYPE')
+    sample_bits = int(pdskey(s, '  SAMPLE_BITS'))
+    # For Messenger MDIS, SAMPLE_BITS is reported as 16, but only values
+    # from 0 ot 4095 are used.
+    bitdepth = 12
+    if sample_type == 'MSB_UNSIGNED_INTEGER':
+        fmt = '>H'
+    else:
+        raise 'Unknown sample type: %s.' % sample_type
+    sample_bytes = (1,2)[bitdepth > 8]
+    row_bytes = sample_bytes * width
+    fmt = fmt[:1] + str(width) + fmt[1:]
+    def rowiter():
+        for y in range(height):
+            yield struct.unpack(fmt, inp.read(row_bytes))
+    info = dict(greyscale=True, alpha=False, bitdepth=bitdepth,
+      size=(width,height), gamma=1.0)
+    return rowiter(), info
+
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+    arg = argv
+    if len(arg) >= 1:
+        f = open(arg[0], 'rb')
+    else:
+        f = sys.stdin
+    pixels,info = img(f)
+    w = png.Writer(**info)
+    w.write(sys.stdout, pixels)
+
+if __name__ == '__main__':
+    main()
+
+
diff --git a/build/pypng/pipasgrey b/build/pypng/pipasgrey
new file mode 100644
index 000000000..2b3727f9a
--- /dev/null
+++ b/build/pypng/pipasgrey
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipasgrey $
+# $Rev: 187 $
+
+# pipasgrey
+
+# Convert image to grey (L, or LA), but only if that involves no colour
+# change.
+
+def asgrey(out, inp, quiet=False):
+    """Convert image to greyscale, but only when no colour change.  This
+    works by using the input G channel (green) as the output L channel
+    (luminance) and checking that every pixel is grey as we go.  A non-grey
+    pixel will raise an error, but if `quiet` is true then the grey pixel
+    check is suppressed.
+    """
+
+    from array import array
+
+    import png
+
+    r = png.Reader(file=inp)
+    _,_,pixels,info = r.asDirect()
+    if info['greyscale']:
+        w = png.Writer(**info)
+        return w.write(out, pixels)
+    planes = info['planes']
+    targetplanes = planes - 2
+    alpha = info['alpha']
+    width = info['size'][0]
+    typecode = 'BH'[info['bitdepth'] > 8]
+    # Values per target row
+    vpr = width * (targetplanes)
+    def iterasgrey():
+        for i,row in enumerate(pixels):
+            row = array(typecode, row)
+            targetrow = array(typecode, [0]*vpr)
+            # Copy G (and possibly A) channel.
+            green = row[0::planes]
+            if alpha:
+                targetrow[0::2] = green
+                targetrow[1::2] = row[3::4]
+            else:
+                targetrow = green
+            # Check R and B channel match.
+            if not quiet and (
+              green != row[0::planes] or green != row[2::planes]):
+                raise ValueError('Row %i contains non-grey pixel.' % i)
+            yield targetrow
+    info['greyscale'] = True
+    del info['planes']
+    w = png.Writer(**info)
+    w.write(out, iterasgrey())
+
+def main(argv=None):
+    from getopt import getopt
+    import sys
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+    opt,argv = getopt(argv, 'q')
+    quiet = False
+    for o,v in opt:
+        if o == '-q':
+            quiet = True
+    if len(argv) > 0:
+        f = open(argv[0], 'rb')
+    else:
+        f = sys.stdin
+    return asgrey(sys.stdout, f, quiet)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipcat b/build/pypng/pipcat
new file mode 100644
index 000000000..e0d080520
--- /dev/null
+++ b/build/pypng/pipcat
@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipcat $
+# $Rev: 77 $
+
+# http://www.python.org/doc/2.4.4/lib/module-itertools.html
+import itertools
+import sys
+
+import png
+
+def cat(out, l):
+    """Concatenate the list of images.  All input images must be same
+    height and have the same number of channels.  They are concatenated
+    left-to-right.  `out` is the (open file) destination for the
+    output image.  `l` should be a list of open files (the input
+    image files).
+    """
+
+    l = map(lambda f: png.Reader(file=f), l)
+    # Ewgh, side effects.
+    map(lambda r: r.preamble(), l)
+    # The reference height; from the first image.
+    height = l[0].height
+    # The total target width
+    width = 0
+    for i,r in enumerate(l):
+        if r.height != height:
+            raise Error('Image %d, height %d, does not match %d.' %
+              (i, r.height, height))
+        width += r.width
+    pixel,info = zip(*map(lambda r: r.asDirect()[2:4], l))
+    tinfo = dict(info[0])
+    del tinfo['size']
+    w = png.Writer(width, height, **tinfo)
+    def itercat():
+        for row in itertools.izip(*pixel):
+            yield itertools.chain(*row)
+    w.write(out, itercat())
+
+def main(argv):
+    return cat(sys.stdout, map(lambda n: open(n, 'rb'), argv[1:]))
+
+if __name__ == '__main__':
+    main(sys.argv)
diff --git a/build/pypng/pipcolours b/build/pypng/pipcolours
new file mode 100644
index 000000000..7c76df8cd
--- /dev/null
+++ b/build/pypng/pipcolours
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipcolours $
+# $Rev: 96 $
+
+# pipcolours - extract all colours present in source image.
+
+def colours(out, inp):
+    import itertools
+    import png
+
+    r = png.Reader(file=inp)
+    _,_,pixels,info = r.asDirect()
+    planes = info['planes']
+    col = set()
+    for row in pixels:
+        # Ewgh, side effects on col
+        map(col.add, png.group(row, planes))
+    col,planes = channel_reduce(col, planes)
+    col = list(col)
+    col.sort()
+    col = list(itertools.chain(*col))
+    width = len(col)//planes
+    greyscale = planes in (1,2)
+    alpha = planes in (2,4)
+    bitdepth = info['bitdepth']
+    w = png.Writer(width, 1,
+        bitdepth=bitdepth, greyscale=greyscale, alpha=alpha)
+    w.write(out, [col])
+
+def channel_reduce(col, planes):
+    """Attempt to reduce the number of channels in the set of
+    colours."""
+    if planes >= 3:
+        def isgrey(c):
+            return c[0] == c[1] == c[2]
+        if min(map(isgrey, col)) == True:
+            # Every colour is grey.
+            col = set(map(lambda x: x[0::3], col))
+            planes -= 2
+    return col,planes
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+
+    argv = argv[1:]
+    if len(argv) > 0:
+        f = open(argv[0], 'rb')
+    else:
+        f = sys.stdin
+    return colours(sys.stdout, f)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipcomposite b/build/pypng/pipcomposite
new file mode 100644
index 000000000..21dd283a6
--- /dev/null
+++ b/build/pypng/pipcomposite
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipcomposite $
+# $Rev: 208 $
+# pipcomposite
+# Image alpha compositing.
+
+"""
+pipcomposite [--background #rrggbb] file.png
+
+Composite an image onto a background and output the result.  The
+background colour is specified with an HTML-style triple (3, 6, or 12
+hex digits), and defaults to black (#000).
+
+The output PNG has no alpha channel.
+
+It is valid for the input to have no alpha channel, but it doesn't
+make much sense: the output will equal the input.
+"""
+
+import sys
+
+def composite(out, inp, background):
+    import png
+
+    p = png.Reader(file=inp)
+    w,h,pixel,info = p.asRGBA()
+
+    outinfo = dict(info)
+    outinfo['alpha'] = False
+    outinfo['planes'] -= 1
+    outinfo['interlace'] = 0
+
+    # Convert to tuple and normalise to same range as source.
+    background = rgbhex(background)
+    maxval = float(2**info['bitdepth'] - 1)
+    background = map(lambda x: int(0.5 + x*maxval/65535.0),
+                     background)
+    # Repeat background so that it's a whole row of sample values.
+    background *= w
+
+    def iterrow():
+        for row in pixel:
+            # Remove alpha from row, then create a list with one alpha
+            # entry _per channel value_.
+            # Squirrel the alpha channel away (and normalise it).
+            t = map(lambda x: x/maxval, row[3::4])
+            row = list(row)
+            del row[3::4]
+            alpha = row[:]
+            for i in range(3):
+                alpha[i::3] = t
+            assert len(alpha) == len(row) == len(background)
+            yield map(lambda a,v,b: int(0.5 + a*v + (1.0-a)*b),
+                      alpha, row, background)
+
+    w = png.Writer(**outinfo)
+    w.write(out, iterrow())
+
+def rgbhex(s):
+    """Take an HTML style string of the form "#rrggbb" and return a
+    colour (R,G,B) triple.  Following the initial '#' there can be 3, 6,
+    or 12 digits (for 4-, 8- or 16- bits per channel).  In all cases the
+    values are expanded to a full 16-bit range, so the returned values
+    are all in range(65536).
+    """
+
+    assert s[0] == '#'
+    s = s[1:]
+    assert len(s) in (3,6,12)
+
+    # Create a target list of length 12, and expand the string s to make
+    # it length 12.
+    l = ['z']*12
+    if len(s) == 3:
+        for i in range(4):
+            l[i::4] = s
+    if len(s) == 6:
+        for i in range(2):
+            l[i::4] = s[i::2]
+            l[i+2::4] = s[i::2]
+    if len(s) == 12:
+        l[:] = s
+    s = ''.join(l)
+    return map(lambda x: int(x, 16), (s[:4], s[4:8], s[8:]))
+
+class Usage(Exception):
+    pass
+
+def main(argv=None):
+    import getopt
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+
+    argv = argv[1:]
+
+    try:
+        try:
+            opt,arg = getopt.getopt(argv, '',
+                                    ['background='])
+        except getopt.error, msg:
+            raise Usage(msg)
+        background = '#000'
+        for o,v in opt:
+            if o in ['--background']:
+                background = v
+    except Usage, err:
+        print >>sys.stderr, __doc__
+        print >>sys.stderr, str(err)
+        return 2
+
+    if len(arg) > 0:
+        f = open(arg[0], 'rb')
+    else:
+        f = sys.stdin
+    return composite(sys.stdout, f, background)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipdither b/build/pypng/pipdither
new file mode 100644
index 000000000..c14c76c3c
--- /dev/null
+++ b/build/pypng/pipdither
@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipdither $
+# $Rev: 150 $
+
+# pipdither
+# Error Diffusing image dithering.
+# Now with serpentine scanning.
+
+# See http://www.efg2.com/Lab/Library/ImageProcessing/DHALF.TXT
+
+# http://www.python.org/doc/2.4.4/lib/module-bisect.html
+from bisect import bisect_left
+
+import png
+
+def dither(out, inp,
+  bitdepth=1, linear=False, defaultgamma=1.0, targetgamma=None,
+  cutoff=0.75):
+    """Dither the input PNG `inp` into an image with a smaller bit depth
+    and write the result image onto `out`.  `bitdepth` specifies the bit
+    depth of the new image.
+    
+    Normally the source image gamma is honoured (the image is
+    converted into a linear light space before being dithered), but
+    if the `linear` argument is true then the image is treated as
+    being linear already: no gamma conversion is done (this is
+    quicker, and if you don't care much about accuracy, it won't
+    matter much).
+    
+    Images with no gamma indication (no ``gAMA`` chunk) are normally
+    treated as linear (gamma = 1.0), but often it can be better
+    to assume a different gamma value: For example continuous tone
+    photographs intended for presentation on the web often carry
+    an implicit assumption of being encoded with a gamma of about
+    0.45 (because that's what you get if you just "blat the pixels"
+    onto a PC framebuffer), so ``defaultgamma=0.45`` might be a
+    good idea.  `defaultgamma` does not override a gamma value
+    specified in the file itself: It is only used when the file
+    does not specify a gamma.
+
+    If you (pointlessly) specify both `linear` and `defaultgamma`,
+    `linear` wins.
+
+    The gamma of the output image is, by default, the same as the input
+    image.  The `targetgamma` argument can be used to specify a
+    different gamma for the output image.  This effectively recodes the
+    image to a different gamma, dithering as we go.  The gamma specified
+    is the exponent used to encode the output file (and appears in the
+    output PNG's ``gAMA`` chunk); it is usually less than 1.
+
+    """
+
+    # Encoding is what happened when the PNG was made (and also what
+    # happens when we output the PNG).  Decoding is what we do to the
+    # source PNG in order to process it.
+
+    # The dithering algorithm is not completely general; it
+    # can only do bit depth reduction, not arbitrary palette changes.
+    import operator
+    maxval = 2**bitdepth - 1
+    r = png.Reader(file=inp)
+    # If image gamma is 1 or gamma is not present and we are assuming a
+    # value of 1, then it is faster to pass a maxval parameter to
+    # asFloat (the multiplications get combined).  With gamma, we have
+    # to have the pixel values from 0.0 to 1.0 (as long as we are doing
+    # gamma correction here).
+    # Slightly annoyingly, we don't know the image gamma until we've
+    # called asFloat().
+    _,_,pixels,info = r.asDirect()
+    planes = info['planes']
+    assert planes == 1
+    width = info['size'][0]
+    sourcemaxval = 2**info['bitdepth'] - 1
+    if linear:
+        gamma = 1
+    else:
+        gamma = info.get('gamma') or defaultgamma
+    # Convert gamma from encoding gamma to the required power for
+    # decoding.
+    decode = 1.0/gamma
+    # Build a lookup table for decoding; convert from pixel values to linear
+    # space:
+    sourcef = 1.0/sourcemaxval
+    incode = map(sourcef.__mul__, range(sourcemaxval+1))
+    if decode != 1.0:
+        incode = map(decode.__rpow__, incode)
+    # Could be different, later on.  targetdecode is the assumed gamma
+    # that is going to be used to decoding the target PNG.  It is the
+    # reciprocal of the exponent that we use to encode the target PNG.
+    # This is the value that we need to build our table that we use for
+    # converting from linear to target colour space.
+    if targetgamma is None:
+        targetdecode = decode
+    else:
+        targetdecode = 1.0/targetgamma
+    # The table we use for encoding (creating the target PNG), still
+    # maps from pixel value to linear space, but we use it inverted, by
+    # searching through it with bisect.
+    targetf = 1.0/maxval
+    outcode = map(targetf.__mul__, range(maxval+1))
+    if targetdecode != 1.0:
+        outcode = map(targetdecode.__rpow__, outcode)
+    # The table used for choosing output codes.  These values represent
+    # the cutoff points between two adjacent output codes.
+    choosecode = zip(outcode[1:], outcode)
+    p = cutoff
+    choosecode = map(lambda x: x[0]*p+x[1]*(1.0-p), choosecode)
+    def iterdither():
+        # Errors diffused downwards (into next row)
+        ed = [0.0]*width
+        flipped = False
+        for row in pixels:
+            row = map(incode.__getitem__, row)
+            row = map(operator.add, ed, row)
+            if flipped:
+                row = row[::-1]
+            targetrow = [0] * width
+            for i,v in enumerate(row):
+                # Clamp.  Necessary because previously added errors may take
+                # v out of range.
+                v = max(0.0, min(v, 1.0))
+                # `it` will be the index of the chosen target colour;
+                it = bisect_left(choosecode, v)
+                t = outcode[it]
+                targetrow[i] = it
+                # err is the error that needs distributing.
+                err = v - t
+                # Sierra "Filter Lite" distributes          * 2
+                # as per this diagram.                    1 1
+                ef = err/2.0
+                # :todo: consider making rows one wider at each end and
+                # removing "if"s
+                if i+1 < width:
+                    row[i+1] += ef
+                ef /= 2.0
+                ed[i] = ef
+                if i:
+                    ed[i-1] += ef
+            if flipped:
+                ed = ed[::-1]
+                targetrow = targetrow[::-1]
+            yield targetrow
+            flipped = not flipped
+    info['bitdepth'] = bitdepth
+    info['gamma'] = 1.0/targetdecode
+    w = png.Writer(**info)
+    w.write(out, iterdither())
+
+
+def main(argv=None):
+    # http://www.python.org/doc/2.4.4/lib/module-getopt.html
+    from getopt import getopt
+    import sys
+    if argv is None:
+        argv = sys.argv
+    opt,argv = getopt(argv[1:], 'b:c:g:lo:')
+    k = {}
+    for o,v in opt:
+        if o == '-b':
+            k['bitdepth'] = int(v)
+        if o == '-c':
+            k['cutoff'] = float(v)
+        if o == '-g':
+            k['defaultgamma'] = float(v)
+        if o == '-l':
+            k['linear'] = True
+        if o == '-o':
+            k['targetgamma'] = float(v)
+        if o == '-?':
+            print >>sys.stderr, "pipdither [-b bits] [-c cutoff] [-g assumed-gamma] [-l] [in.png]"
+
+    if len(argv) > 0:
+        f = open(argv[0], 'rb')
+    else:
+        f = sys.stdin
+
+    return dither(sys.stdout, f, **k)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/piprgb b/build/pypng/piprgb
new file mode 100644
index 000000000..fbe1082af
--- /dev/null
+++ b/build/pypng/piprgb
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/piprgb $
+# $Rev: 131 $
+# piprgb
+#
+# Convert input image to RGB or RGBA format.  Output will be colour type
+# 2 or 6, and will not have a tRNS chunk.
+
+import png
+
+def rgb(out, inp):
+    """Convert to RGB/RGBA."""
+
+    r = png.Reader(file=inp)
+    r.preamble()
+    if r.alpha or r.trns:
+        get = r.asRGBA
+    else:
+        get = r.asRGB
+    pixels,info = get()[2:4]
+    w = png.Writer(**info)
+    w.write(out, pixels)
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    if len(argv) > 1:
+        f = open(argv[1], 'rb')
+    else:
+        f = sys.stdin
+    return rgb(sys.stdout, f)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipscalez b/build/pypng/pipscalez
new file mode 100644
index 000000000..c60762d7f
--- /dev/null
+++ b/build/pypng/pipscalez
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipscalez $
+# $Rev: 131 $
+
+# pipscalez
+# Enlarge an image by an integer factor horizontally and vertically.
+
+def rescale(inp, out, xf, yf):
+    from array import array
+    import png
+
+    r = png.Reader(file=inp)
+    _,_,pixels,meta = r.asDirect()
+    typecode = 'BH'[meta['bitdepth'] > 8]
+    planes = meta['planes']
+    # We are going to use meta in the call to Writer, so expand the
+    # size.
+    x,y = meta['size']
+    x *= xf
+    y *= yf
+    meta['size'] = (x,y)
+    del x
+    del y
+    # Values per row, target row.
+    vpr = meta['size'][0] * planes
+    def iterscale():
+        for row in pixels:
+            bigrow = array(typecode, [0]*vpr)
+            row = array(typecode, row)
+            for c in range(planes):
+                channel = row[c::planes]
+                for i in range(xf):
+                    bigrow[i*planes+c::xf*planes] = channel
+            for _ in range(yf):
+                yield bigrow
+    w = png.Writer(**meta)
+    w.write(out, iterscale())
+
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    xf = int(argv[1])
+    if len(argv) > 2:
+        yf = int(argv[2])
+    else:
+        yf = xf
+    return rescale(sys.stdin, sys.stdout, xf, yf)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipstack b/build/pypng/pipstack
new file mode 100644
index 000000000..5523670e4
--- /dev/null
+++ b/build/pypng/pipstack
@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipstack $
+# $Rev: 190 $
+
+# pipstack
+# Combine input PNG files into a multi-channel output PNG.
+
+"""
+pipstack file1.png [file2.png ...]
+
+pipstack can be used to combine 3 greyscale PNG files into a colour, RGB,
+PNG file.  In fact it is slightly more general than that.  The number of
+channels in the output PNG is equal to the sum of the numbers of
+channels in the input images.  It is an error if this sum exceeds 4 (the
+maximum number of channels in a PNG image is 4, for an RGBA image).  The
+output colour model corresponds to the number of channels: 1 -
+greyscale; 2 - greyscale+alpha; 3 - RGB; 4 - RGB+alpha.
+
+In this way it is possible to combine 3 greyscale PNG files into an RGB
+PNG (a common expected use) as well as more esoteric options: rgb.png +
+grey.png = rgba.png; grey.png + grey.png = greyalpha.png.
+
+Color Profile, Gamma, and so on.
+
+[This is not implemented yet]
+
+If an input has an ICC Profile (``iCCP`` chunk) then the output will
+have an ICC Profile, but only if it is possible to combine all the input
+ICC Profiles.  It is possible to combine all the input ICC Profiles
+only when: they all use the same Profile Connection Space; the PCS white
+point is the same (specified in the header; should always be D50);
+possibly some other things I haven't thought of yet.
+
+If some of the inputs have a ``gAMA`` chunk (specifying gamma) and
+an output ICC Profile is being generated, then the gamma information
+will be incorporated into the ICC Profile.
+
+When the output is an RGB colour type and the output ICC Profile is
+synthesized, it is necessary to supply colorant tags (``rXYZ`` and so
+on).  These are taken from ``sRGB``.
+
+If the input images have ``gAMA`` chunks and no input image has an ICC
+Profile then the output image will have a ``gAMA`` chunk, but only if
+all the ``gAMA`` chunks specify the same value.  Otherwise a warning
+will be emitted and no ``gAMA`` chunk.  It is possible to add or replace
+a ``gAMA`` chunk using the ``pipchunk`` tool.
+
+gAMA, pHYs, iCCP, sRGB, tIME, any other chunks.
+"""
+
+class Error(Exception):
+    pass
+
+def stack(out, inp):
+    """Stack the input PNG files into a single output PNG."""
+
+    from array import array
+    import itertools
+    # Local module
+    import png
+
+    if len(inp) < 1:
+        raise Error("Required input is missing.")
+
+    l = map(png.Reader, inp)
+    # Let data be a list of (pixel,info) pairs.
+    data = map(lambda p: p.asDirect()[2:], l)
+    totalchannels = sum(map(lambda x: x[1]['planes'], data))
+
+    if not (0 < totalchannels <= 4):
+        raise Error("Too many channels in input.")
+    alpha = totalchannels in (2,4)
+    greyscale = totalchannels in (1,2)
+    bitdepth = []
+    for b in map(lambda x: x[1]['bitdepth'], data):
+        try:
+            if b == int(b):
+                bitdepth.append(b)
+                continue
+        except (TypeError, ValueError):
+            pass
+        # Assume a tuple.
+        bitdepth += b
+    # Currently, fail unless all bitdepths equal.
+    if len(set(bitdepth)) > 1:
+        raise NotImplemented("Cannot cope when bitdepths differ - sorry!")
+    bitdepth = bitdepth[0]
+    arraytype = 'BH'[bitdepth > 8]
+    size = map(lambda x: x[1]['size'], data)
+    # Currently, fail unless all images same size.
+    if len(set(size)) > 1:
+        raise NotImplemented("Cannot cope when sizes differ - sorry!")
+    size = size[0]
+    # Values per row
+    vpr = totalchannels * size[0]
+    def iterstack():
+        # the izip call creates an iterator that yields the next row
+        # from all the input images combined into a tuple.
+        for irow in itertools.izip(*map(lambda x: x[0], data)):
+            row = array(arraytype, [0]*vpr)
+            # output channel
+            och = 0
+            for i,arow in enumerate(irow):
+                # ensure incoming row is an array
+                arow = array(arraytype, arow)
+                n = data[i][1]['planes']
+                for j in range(n):
+                    row[och::totalchannels] = arow[j::n]
+                    och += 1
+            yield row
+    w = png.Writer(size[0], size[1],
+      greyscale=greyscale, alpha=alpha, bitdepth=bitdepth)
+    w.write(out, iterstack())
+
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+    arg = argv[:]
+    return stack(sys.stdout, arg)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pipwindow b/build/pypng/pipwindow
new file mode 100644
index 000000000..2f8c7a266
--- /dev/null
+++ b/build/pypng/pipwindow
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pipwindow $
+# $Rev: 173 $
+
+# pipwindow
+# Tool to crop/expand an image to a rectangular window.  Come the
+# revolution this tool will allow the image and the window to be placed
+# arbitrarily (in particular the window can be bigger than the picture
+# and/or overlap it only partially) and the image can be OpenGL style
+# border/repeat effects (repeat, mirrored repeat, clamp, fixed
+# background colour, background colour from source file).  For now it
+# only acts as crop.  The window must be no greater than the image in
+# both x and y.
+
+def window(tl, br, inp, out):
+    """Place a window onto the image and cut-out the resulting
+    rectangle.  The window is an axis aligned rectangle opposite corners
+    at *tl* and *br* (each being an (x,y) pair). *inp* specifies the
+    input file which should be a PNG image.
+    """
+
+    import png
+
+    r = png.Reader(file=inp)
+    x,y,pixels,meta = r.asDirect()
+    if not (0 <= tl[0] < br[0] <= x):
+        raise NotImplementedError()
+    if not (0 <= tl[1] < br[1] <= y):
+        raise NotImplementedError()
+    # Compute left and right bounds for each row
+    l = tl[0] * meta['planes']
+    r = br[0] * meta['planes']
+    def itercrop():
+        """An iterator to perform the crop."""
+
+        for i,row in enumerate(pixels):
+            if i < tl[1]:
+                continue
+            if i >= br[1]:
+                # Same as "raise StopIteration"
+                return
+            yield row[l:r]
+    meta['size'] = (br[0]-tl[0], br[1]-tl[1])
+    w = png.Writer(**meta)
+    w.write(out, itercrop())
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+
+    tl = (0,0)
+    br = tuple(map(int, argv[:2]))
+    if len(argv) >= 4:
+        tl = br
+        br = tuple(map(int, argv[2:4]))
+    if len(argv) in (2, 4):
+        f = sys.stdin
+    else:
+        f = open(argv[-1], 'rb')
+
+    return window(tl, br, f, sys.stdout)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/plan9topng.py b/build/pypng/plan9topng.py
new file mode 100644
index 000000000..4600b4c98
--- /dev/null
+++ b/build/pypng/plan9topng.py
@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+# $Rev: 184 $
+# $URL: http://pypng.googlecode.com/svn/trunk/code/plan9topng.py $
+
+# Imported from //depot/prj/plan9topam/master/code/plan9topam.py#4 on
+# 2009-06-15.
+
+"""Command line tool to convert from Plan 9 image format to PNG format.
+
+Plan 9 image format description:
+http://plan9.bell-labs.com/magic/man2html/6/image
+"""
+
+# http://www.python.org/doc/2.3.5/lib/module-itertools.html
+import itertools
+# http://www.python.org/doc/2.3.5/lib/module-re.html
+import re
+# http://www.python.org/doc/2.3.5/lib/module-sys.html
+import sys
+
+def block(s, n):
+    # See http://www.python.org/doc/2.6.2/library/functions.html#zip
+    return zip(*[iter(s)]*n)
+
+def convert(f, output=sys.stdout) :
+  """Convert Plan 9 file to PNG format.  Works with either uncompressed
+  or compressed files.
+  """
+
+  r = f.read(11)
+  if r == 'compressed\n' :
+    png(output, *decompress(f))
+  else :
+    png(output, *glue(f, r))
+
+
+def glue(f, r) :
+  """Return (metadata, stream) pair where `r` is the initial portion of
+  the metadata that has already been read from the stream `f`.
+  """
+
+  r = r + f.read(60-len(r))
+  return (r, f)
+
+def meta(r) :
+  """Convert 60 character string `r`, the metadata from an image file.
+  Returns a 5-tuple (*chan*,*minx*,*miny*,*limx*,*limy*).  5-tuples may
+  settle into lists in transit.
+  
+  As per http://plan9.bell-labs.com/magic/man2html/6/image the metadata
+  comprises 5 words separated by blanks.  As it happens each word starts
+  at an index that is a multiple of 12, but this routine does not care
+  about that."""
+
+  r = r.split()
+  # :todo: raise FormatError
+  assert len(r) == 5
+  r = [r[0]] + map(int, r[1:])
+  return r
+
+def bitdepthof(pixel) :
+    """Return the bitdepth for a Plan9 pixel format string."""
+
+    maxd = 0
+    for c in re.findall(r'[a-z]\d*', pixel) :
+        if c[0] != 'x':
+            maxd = max(maxd, int(c[1:]))
+    return maxd
+
+def maxvalof(pixel):
+  """Return the netpbm MAXVAL for a Plan9 pixel format string."""
+
+  bitdepth = bitdepthof(pixel)
+  return (2**bitdepth)-1
+
+def pixmeta(metadata, f) :
+    """Convert (uncompressed) Plan 9 image file to pair of (*metadata*,
+    *pixels*).  This is intended to be used by PyPNG format.  *metadata*
+    is the metadata returned in a dictionary, *pixels* is an iterator that
+    yields each row in boxed row flat pixel format.
+
+    `f`, the input file, should be cued up to the start of the image data.
+    """
+
+    chan,minx,miny,limx,limy = metadata
+    rows = limy - miny
+    width = limx - minx
+    nchans = len(re.findall('[a-wyz]', chan))
+    alpha = 'a' in chan
+    # Iverson's convention for the win!
+    ncolour = nchans - alpha
+    greyscale = ncolour == 1
+    bitdepth = bitdepthof(chan)
+    maxval = 2**bitdepth - 1
+    # PNG style metadata
+    meta=dict(size=(width,rows), bitdepth=bitdepthof(chan),
+      greyscale=greyscale, alpha=alpha, planes=nchans)
+
+    return itertools.imap(lambda x: itertools.chain(*x),
+      block(unpack(f, rows, width, chan, maxval), width)), meta
+
+def png(out, metadata, f):
+    """Convert to PNG format.  `metadata` should be a Plan9 5-tuple; `f`
+    the input file (see :meth:`pixmeta`).
+    """
+
+    import png
+
+    pixels,meta = pixmeta(metadata, f)
+    p = png.Writer(**meta)
+    p.write(out, pixels)
+
+def spam():
+  """Not really spam, but old PAM code, which is in limbo."""
+
+  if nchans == 3 or nchans == 1 :
+    # PGM (P5) or PPM (P6) format.
+    output.write('P%d\n%d %d %d\n' % (5+(nchans==3), width, rows, maxval))
+  else :
+    # PAM format.
+    output.write("""P7
+WIDTH %d
+HEIGHT %d
+DEPTH %d
+MAXVAL %d
+""" % (width, rows, nchans, maxval))
+
+def unpack(f, rows, width, pixel, maxval) :
+  """Unpack `f` into pixels.  Assumes the pixel format is such that the depth
+  is either a multiple or a divisor of 8.
+  `f` is assumed to be an iterator that returns blocks of input such
+  that each block contains a whole number of pixels.  An iterator is
+  returned that yields each pixel as an n-tuple.  `pixel` describes the
+  pixel format using the Plan9 syntax ("k8", "r8g8b8", and so on).
+  """
+
+  def mask(w) :
+    """An integer, to be used as a mask, with bottom `w` bits set to 1."""
+
+    return (1 << w)-1
+
+  def deblock(f, depth, width) :
+    """A "packer" used to convert multiple bytes into single pixels.
+    `depth` is the pixel depth in bits (>= 8), `width` is the row width in
+    pixels.
+    """
+
+    w = depth // 8
+    i = 0
+    for block in f :
+      for i in range(len(block)//w) :
+        p = block[w*i:w*(i+1)]
+        i += w
+        # Convert p to little-endian integer, x
+        x = 0
+        s = 1 # scale
+        for j in p :
+          x += s * ord(j)
+          s <<= 8
+        yield x
+
+  def bitfunge(f, depth, width) :
+    """A "packer" used to convert single bytes into multiple pixels.
+    Depth is the pixel depth (< 8), width is the row width in pixels.
+    """
+
+    for block in f :
+      col = 0
+      for i in block :
+        x = ord(i)
+        for j in range(8/depth) :
+          yield x >> (8 - depth)
+          col += 1
+          if col == width :
+            # A row-end forces a new byte even if we haven't consumed
+            # all of the current byte.  Effectively rows are bit-padded
+            # to make a whole number of bytes.
+            col = 0
+            break
+          x <<= depth
+
+  # number of bits in each channel
+  chan = map(int, re.findall(r'\d+', pixel))
+  # type of each channel
+  type = re.findall('[a-z]', pixel)
+
+  depth = sum(chan)
+
+  # According to the value of depth pick a "packer" that either gathers
+  # multiple bytes into a single pixel (for depth >= 8) or split bytes
+  # into several pixels (for depth < 8)
+  if depth >= 8 :
+    # 
+    assert depth % 8 == 0
+    packer = deblock
+  else :
+    assert 8 % depth == 0
+    packer = bitfunge
+
+  for x in packer(f, depth, width) :
+    # x is the pixel as an unsigned integer
+    o = []
+    # This is a bit yucky.  Extract each channel from the _most_
+    # significant part of x.
+    for j in range(len(chan)) :
+      v = (x >> (depth - chan[j])) & mask(chan[j])
+      x <<= chan[j]
+      if type[j] != 'x' :
+        # scale to maxval
+        v = v * float(maxval) / mask(chan[j])
+        v = int(v+0.5)
+        o.append(v)
+    yield o
+
+
+def decompress(f) :
+  """Decompress a Plan 9 image file.  Assumes f is already cued past the
+  initial 'compressed\n' string.
+  """
+
+  r = meta(f.read(60))
+  return r, decomprest(f, r[4])
+
+
+def decomprest(f, rows) :
+  """Iterator that decompresses the rest of a file once the metadata
+  have been consumed."""
+
+  row = 0
+  while row < rows :
+    row,o = deblock(f)
+    yield o
+
+
+def deblock(f) :
+  """Decompress a single block from a compressed Plan 9 image file.
+  Each block starts with 2 decimal strings of 12 bytes each.  Yields a
+  sequence of (row, data) pairs where row is the total number of rows
+  processed according to the file format and data is the decompressed
+  data for a set of rows."""
+
+  row = int(f.read(12))
+  size = int(f.read(12))
+  if not (0 <= size <= 6000) :
+    raise 'block has invalid size; not a Plan 9 image file?'
+
+  # Since each block is at most 6000 bytes we may as well read it all in
+  # one go.
+  d = f.read(size)
+  i = 0
+  o = []
+
+  while i < size :
+    x = ord(d[i])
+    i += 1
+    if x & 0x80 :
+      x = (x & 0x7f) + 1
+      lit = d[i:i+x]
+      i += x
+      o.extend(lit)
+      continue
+    # x's high-order bit is 0
+    l = (x >> 2) + 3
+    # Offset is made from bottom 2 bits of x and all 8 bits of next
+    # byte.  http://plan9.bell-labs.com/magic/man2html/6/image doesn't
+    # say whether x's 2 bits are most signiificant or least significant.
+    # But it is clear from inspecting a random file,
+    # http://plan9.bell-labs.com/sources/plan9/sys/games/lib/sokoban/images/cargo.bit
+    # that x's 2 bit are most significant.
+    # 
+    offset = (x & 3) << 8
+    offset |= ord(d[i])
+    i += 1
+    # Note: complement operator neatly maps (0 to 1023) to (-1 to
+    # -1024).  Adding len(o) gives a (non-negative) offset into o from
+    # which to start indexing.
+    offset = ~offset + len(o)
+    if offset < 0 :
+      raise 'byte offset indexes off the begininning of the output buffer; not a Plan 9 image file?'
+    for j in range(l) :
+      o.append(o[offset+j])
+  return row,''.join(o)
+
+def main(argv=None) :
+  if argv is None :
+    argv = sys.argv
+  if len(sys.argv) <= 1 :
+    return convert(sys.stdin)
+  else :
+    return convert(open(argv[1], 'rb'))
+
+if __name__ == '__main__' :
+  sys.exit(main())
diff --git a/build/pypng/pngchunk b/build/pypng/pngchunk
new file mode 100644
index 000000000..b00e4b1de
--- /dev/null
+++ b/build/pypng/pngchunk
@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pngchunk $
+# $Rev: 156 $
+# pngchunk
+# Chunk editing/extraction tool.
+
+import struct
+import warnings
+
+# Local module.
+import png
+
+"""
+pngchunk [--gamma g] [--iccprofile file] [--sigbit b] [-c cHNK!] [-c cHNK:foo] [-c cHNK<file]
+
+The ``-c`` option is used to add or remove chunks.  A chunk is specified
+by its 4 byte chunk type.  If this is followed by a ``!`` then that
+chunk is removed from the PNG file.  If the chunk type is followed by a
+``:`` then the chunk is replaced with the contents of the rest of the
+argument (this is probably only useful if the content is mostly ASCII,
+otherwise it's a pain to quote the contents, otherwise see...).  A ``<``
+can be used to take the contents of the chunk from the named file.
+"""
+
+
+def chunk(out, inp, l):
+    """Process the input PNG file to the output, chunk by chunk.  Chunks
+    can be inserted, removed, replaced, or sometimes edited.  Generally, 
+    chunks are not inspected, so pixel data (in the ``IDAT`` chunks)
+    cannot be modified.  `l` should be a list of (*chunktype*,
+    *content*) pairs.  *chunktype* is usually the type of the PNG chunk,
+    specified as a 4-byte Python string, and *content* is the chunk's
+    content, also as a string; if *content* is ``None`` then *all*
+    chunks of that type will be removed.
+
+    This function *knows* about certain chunk types and will
+    automatically convert from Python friendly representations to
+    string-of-bytes.
+
+    chunktype
+    'gamma'     'gAMA'  float
+    'sigbit'    'sBIT'  int, or tuple of length 1,2 or 3
+
+    Note that the length of the strings used to identify *friendly*
+    chunk types is greater than 4, hence they cannot be confused with
+    canonical chunk types.
+
+    Chunk types, if specified using the 4-byte syntax, need not be
+    official PNG chunks at all.  Non-standard chunks can be created.
+    """
+
+    def canonical(p):
+        """Take a pair (*chunktype*, *content*), and return canonical
+        representation (*chunktype*, *content*) where `chunktype` is the
+        4-byte PNG chunk type and `content` is a string.
+        """
+
+        t,v = p
+        if len(t) == 4:
+            return t,v
+        if t == 'gamma':
+            t = 'gAMA'
+            v = int(round(1e5*v))
+            v = struct.pack('>I', v)
+        elif t == 'sigbit':
+            t = 'sBIT'
+            try:
+                v[0]
+            except TypeError:
+                v = (v,)
+            v = struct.pack('%dB' % len(v), *v)
+        elif t == 'iccprofile':
+            t = 'iCCP'
+            # http://www.w3.org/TR/PNG/#11iCCP
+            v = 'a color profile\x00\x00' + v.encode('zip')
+        else:
+            warnings.warn('Unknown chunk type %r' % t)
+        return t[:4],v
+
+    l = map(canonical, l)
+    # Some chunks automagically replace ones that are present in the
+    # source PNG.  There can only be one of each of these chunk types.
+    # Create a 'replace' dictionary to record these chunks.
+    add = []
+    delete = set()
+    replacing = set(['gAMA', 'sBIT', 'PLTE', 'tRNS', 'sPLT', 'IHDR'])
+    replace = dict()
+    for t,v in l:
+        if v is None:
+            delete.add(t)
+        elif t in replacing:
+            replace[t] = v
+        else:
+            add.append((t,v))
+    del l
+    r = png.Reader(file=inp)
+    chunks = r.chunks()
+    def iterchunks():
+        for t,v in chunks:
+            if t in delete:
+                continue
+            if t in replace:
+                yield t,replace[t]
+                del replace[t]
+                continue
+            if t == 'IDAT' and replace:
+                # Insert into the output any chunks that are on the
+                # replace list.  We haven't output them yet, because we
+                # didn't see an original chunk of the same type to
+                # replace.  Thus the "replace" is actually an "insert".
+                for u,w in replace.items():
+                    yield u,w
+                    del replace[u]
+            if t == 'IDAT' and add:
+                for item in add:
+                    yield item
+                del add[:]
+            yield t,v
+    return png.write_chunks(out, iterchunks())
+
+class Usage(Exception):
+    pass
+
+def main(argv=None):
+    import getopt
+    import re
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+
+    argv = argv[1:]
+
+    try:
+        try:
+            opt,arg = getopt.getopt(argv, 'c:',
+                                    ['gamma=', 'iccprofile=', 'sigbit='])
+        except getopt.error, msg:
+            raise Usage(msg)
+        k = []
+        for o,v in opt:
+            if o in ['--gamma']:
+                k.append(('gamma', float(v)))
+            if o in ['--sigbit']:
+                k.append(('sigbit', int(v)))
+            if o in ['--iccprofile']:
+                k.append(('iccprofile', open(v, 'rb').read()))
+            if o in ['-c']:
+                type = v[:4]
+                if not re.match('[a-zA-Z]{4}', type):
+                    raise Usage('Chunk type must consist of 4 letters.')
+                if v[4] == '!':
+                    k.append((type, None))
+                if v[4] == ':':
+                    k.append((type, v[5:]))
+                if v[4] == '<':
+                    k.append((type, open(v[5:], 'rb').read()))
+    except Usage, err:
+        print >>sys.stderr, (
+          "usage: pngchunk [--gamma d.dd] [--sigbit b] [-c cHNK! | -c cHNK:text-string]")
+        print >>sys.stderr, err.message
+        return 2
+
+    if len(arg) > 0:
+        f = open(arg[0], 'rb')
+    else:
+        f = sys.stdin
+    return chunk(sys.stdout, f, k)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pnghist b/build/pypng/pnghist
new file mode 100644
index 000000000..4fbbd0a6e
--- /dev/null
+++ b/build/pypng/pnghist
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pnghist $
+# $Rev: 153 $
+# PNG Histogram
+# Only really works on grayscale images.
+
+from array import array
+import getopt
+
+import png
+
+def decidemax(level):
+    """Given an array of levels, decide the maximum value to use for the
+    histogram.  This is normally chosen to be a bit bigger than the 99th
+    percentile, but if the 100th percentile is not much more (within a
+    factor of 2) then the 100th percentile is chosen.
+    """
+
+    truemax = max(level)
+    sl = level[:]
+    sl.sort(reverse=True)
+    i99 = int(round(len(level)*0.01))
+    if truemax <= 2*sl[i99]:
+        return truemax
+    return 1.05*sl[i99]
+
+def hist(out, inp, verbose=None):
+    """Open the PNG file `inp` and generate a histogram."""
+
+    r = png.Reader(file=inp)
+    x,y,pixels,info = r.asDirect()
+    bitdepth = info['bitdepth']
+    level = [0]*2**bitdepth
+    for row in pixels:
+        for v in row:
+            level[v] += 1
+    maxlevel = decidemax(level)
+
+    h = 100
+    outbitdepth = 8
+    outmaxval = 2**outbitdepth - 1
+    def genrow():
+        for y in range(h):
+            y = h-y-1
+            # :todo: vary typecode according to outbitdepth
+            row = array('B', [0]*len(level))
+            fl = y*maxlevel/float(h)
+            ce = (y+1)*maxlevel/float(h)
+            for x in range(len(row)):
+                if level[x] <= fl:
+                    # Relies on row being initialised to all 0
+                    continue
+                if level[x] >= ce:
+                    row[x] = outmaxval
+                    continue
+                frac = (level[x] - fl)/(ce - fl)
+                row[x] = int(round(outmaxval*frac))
+            yield row
+    w = png.Writer(len(level), h, gamma=1.0,
+      greyscale=True, alpha=False, bitdepth=outbitdepth)
+    w.write(out, genrow())
+    if verbose: print >>verbose, level
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    argv = argv[1:]
+    opt,arg = getopt.getopt(argv, '')
+
+    if len(arg) < 1:
+        f = sys.stdin
+    else:
+        f = open(arg[0])
+    hist(sys.stdout, f)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/pnglsch b/build/pypng/pnglsch
new file mode 100644
index 000000000..d10d23809
--- /dev/null
+++ b/build/pypng/pnglsch
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/pnglsch $
+# $Rev: 107 $
+# pnglsch
+# PNG List Chunks
+
+import png
+
+def list(out, inp):
+    r = png.Reader(file=inp)
+    for t,v in r.chunks():
+        add = ''
+        if len(v) <= 28:
+            add = ' ' + v.encode('hex')
+        print >>out, "%s %10d%s" % (t, len(v), add)
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    arg = argv[1:]
+
+    if len(arg) > 0:
+        f = open(arg[0], 'rb')
+    else:
+        f = sys.stdin
+    return list(sys.stdout, f)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/pypng/texttopng b/build/pypng/texttopng
new file mode 100644
index 000000000..ab0c6900a
--- /dev/null
+++ b/build/pypng/texttopng
@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+# $URL: http://pypng.googlecode.com/svn/trunk/code/texttopng $
+# $Rev: 132 $
+# Script to renders text as a PNG image.
+
+from array import array
+import itertools
+
+font = {
+  32: '0000000000000000',
+  33: '0010101010001000',
+  34: '0028280000000000',
+  35: '0000287c287c2800',
+  36: '00103c5038147810',
+  37: '0000644810244c00',
+  38: '0020502054483400',
+  39: '0010100000000000',
+  40: '0008101010101008',
+  41: '0020101010101020',
+  42: '0010543838541000',
+  43: '000010107c101000',
+  44: '0000000000301020',
+  45: '000000007c000000',
+  46: '0000000000303000',
+  47: '0000040810204000',
+  48: '0038445454443800',
+  49: '0008180808080800',
+  50: '0038043840407c00',
+  51: '003c041804043800',
+  52: '00081828487c0800',
+  53: '0078407804047800',
+  54: '0038407844443800',
+  55: '007c040810101000',
+  56: '0038443844443800',
+  57: '0038443c04040400',
+  58: '0000303000303000',
+  59: '0000303000301020',
+  60: '0004081020100804',
+  61: '0000007c007c0000',
+  62: '0040201008102040',
+  63: '0038440810001000',
+  64: '00384c545c403800',
+  65: '0038447c44444400',
+  66: '0078447844447800',
+  67: '0038444040443800',
+  68: '0070484444487000',
+  69: '007c407840407c00',
+  70: '007c407840404000',
+  71: '003844405c443c00',
+  72: '0044447c44444400',
+  73: '0038101010103800',
+  74: '003c040404443800',
+  75: '0044487048444400',
+  76: '0040404040407c00',
+  77: '006c545444444400',
+  78: '004464544c444400',
+  79: '0038444444443800',
+  80: '0078447840404000',
+  81: '0038444444443c02',
+  82: '0078447844444400',
+  83: '0038403804047800',
+  84: '007c101010101000',
+  85: '0044444444443c00',
+  86: '0044444444281000',
+  87: '0044445454543800',
+  88: '0042241818244200',
+  89: '0044443810101000',
+  90: '007c081020407c00',
+  91: '0038202020202038',
+  92: '0000402010080400',
+  93: '0038080808080838',
+  94: '0010284400000000',
+  95: '000000000000fe00',
+  96: '0040200000000000',
+  97: '000038043c443c00',
+  98: '0040784444447800',
+  99: '0000384040403800',
+  100: '00043c4444443c00',
+  101: '000038447c403c00',
+  102: '0018203820202000',
+  103: '00003c44443c0438',
+  104: '0040784444444400',
+  105: '0010003010101000',
+  106: '0010003010101020',
+  107: '0040404870484400',
+  108: '0030101010101000',
+  109: '0000385454444400',
+  110: '0000784444444400',
+  111: '0000384444443800',
+  112: '0000784444784040',
+  113: '00003c44443c0406',
+  114: '00001c2020202000',
+  115: '00003c4038047800',
+  116: '0020203820201800',
+  117: '0000444444443c00',
+  118: '0000444444281000',
+  119: '0000444454543800',
+  120: '0000442810284400',
+  121: '00004444443c0438',
+  122: '00007c0810207c00',
+  123: '0018202060202018',
+  124: '0010101000101010',
+  125: '003008080c080830',
+  126: '0020540800000000',
+}
+
+def char(i):
+    """Get image data for the character `i` (a one character string).
+    Returned as a list of rows.  Each row is a tuple containing the
+    packed pixels.
+    """
+
+    i = ord(i)
+    if i not in font:
+        return [(0,)]*8
+    return map(lambda row: (ord(row),), font[i].decode('hex'))
+
+def texttoraster(m):
+    """Convert string *m* to a raster image (by rendering it using the
+    font in *font*).  A triple of (*width*, *height*, *pixels*) is
+    returned; *pixels* is in boxed row packed pixel format.
+    """
+
+    # Assumes monospaced font.
+    x = 8*len(m)
+    y = 8
+    return x,y,itertools.imap(lambda row: itertools.chain(*row),
+                              zip(*map(char, m)))
+
+
+def render(message, out):
+    import png
+
+    x,y,pixels = texttoraster(message)
+    w = png.Writer(x, y, greyscale=True, bitdepth=1)
+    w.write_packed(out, pixels)
+    out.flush()
+
+def main(argv=None):
+    import sys
+
+    if argv is None:
+        argv = sys.argv
+    if len(argv) > 1:
+        message = argv[1]
+    else:
+        message = sys.stdin.read()
+    render(message, sys.stdout)
+
+if __name__ == '__main__':
+    main()
diff --git a/build/unix/mozconfig.gtk b/build/unix/mozconfig.gtk
new file mode 100644
index 000000000..6f535f8a7
--- /dev/null
+++ b/build/unix/mozconfig.gtk
@@ -0,0 +1,28 @@
+# To do try builds with Gtk+2, uncomment the following line, and remove
+# everything after that.
+#ac_add_options --enable-default-toolkit=cairo-gtk2
+
+TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
+
+# $TOOLTOOL_DIR/gtk3 comes from tooltool, and must be included in the tooltool manifest.
+if [ -z "$PKG_CONFIG_LIBDIR" ]; then
+  echo PKG_CONFIG_LIBDIR must be set >&2
+  exit 1
+fi
+export PKG_CONFIG_SYSROOT_DIR="$TOOLTOOL_DIR/gtk3"
+export PKG_CONFIG_PATH="$TOOLTOOL_DIR/gtk3/usr/local/lib/pkgconfig"
+PKG_CONFIG="$TOOLTOOL_DIR/gtk3/usr/local/bin/pkg-config"
+export PATH="$TOOLTOOL_DIR/gtk3/usr/local/bin:${PATH}"
+# Ensure cairo, gdk-pixbuf, etc. are not taken from the system installed packages.
+LDFLAGS="-L$TOOLTOOL_DIR/gtk3/usr/local/lib ${LDFLAGS}"
+ac_add_options --enable-default-toolkit=cairo-gtk3
+
+# Set things up to use Gtk+3 from the tooltool package
+mk_add_options "export FONTCONFIG_PATH=$TOOLTOOL_DIR/gtk3/usr/local/etc/fonts"
+mk_add_options "export PANGO_SYSCONFDIR=$TOOLTOOL_DIR/gtk3/usr/local/etc"
+mk_add_options "export PANGO_LIBDIR=$TOOLTOOL_DIR/gtk3/usr/local/lib"
+mk_add_options "export GDK_PIXBUF_MODULE_FILE=$TOOLTOOL_DIR/gtk3/usr/local/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache"
+mk_add_options "export GDK_PIXBUF_MODULEDIR=$TOOLTOOL_DIR/gtk3/usr/local/lib/gdk-pixbuf-2.0/2.10.0/loaders"
+
+LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOOLTOOL_DIR/gtk3/usr/local/lib
+mk_add_options "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
diff --git a/build/unix/mozconfig.linux b/build/unix/mozconfig.linux
new file mode 100644
index 000000000..f63f406e6
--- /dev/null
+++ b/build/unix/mozconfig.linux
@@ -0,0 +1,38 @@
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPLOAD_SYMBOLS=${MOZ_AUTOMATION_UPLOAD_SYMBOLS-1}
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+
+. "$topsrcdir/build/mozconfig.common"
+
+TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
+
+# some b2g desktop builds still happen on i686 machines, and the tooltool
+# toolchain is x86_64 only.
+# We also deal with valgrind builds here, they don't use tooltool manifests at
+# all yet.
+if [ -z "$no_tooltool" ]
+then
+  CC="$TOOLTOOL_DIR/gcc/bin/gcc"
+  CXX="$TOOLTOOL_DIR/gcc/bin/g++"
+
+  # We want to make sure we use binutils and other binaries in the tooltool
+  # package.
+  mk_add_options PATH="$TOOLTOOL_DIR/gcc/bin:$PATH"
+else
+  CC="/tools/gcc-4.7.3-0moz1/bin/gcc"
+  CXX="/tools/gcc-4.7.3-0moz1/bin/g++"
+fi
+
+ac_add_options --enable-elf-hack
+
+. "$topsrcdir/build/unix/mozconfig.stdcxx"
+
+# PKG_CONFIG_LIBDIR is appropriately overridden in mozconfig.linux32
+export PKG_CONFIG_LIBDIR=/usr/lib64/pkgconfig:/usr/share/pkgconfig
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=/builds/crash-stats-api.token
+
+. "$topsrcdir/build/unix/mozconfig.gtk"
diff --git a/build/unix/mozconfig.linux32 b/build/unix/mozconfig.linux32
new file mode 100644
index 000000000..309767751
--- /dev/null
+++ b/build/unix/mozconfig.linux32
@@ -0,0 +1,12 @@
+. "$topsrcdir/build/unix/mozconfig.linux"
+
+export PKG_CONFIG_LIBDIR=/usr/lib/pkgconfig:/usr/share/pkgconfig
+
+if test `uname -m` = "x86_64"; then
+  # -march=pentiumpro is what our 32-bit native toolchain defaults to
+  CC="$CC -m32 -march=pentiumpro"
+  CXX="$CXX -m32 -march=pentiumpro"
+  ac_add_options --target=i686-pc-linux
+  ac_add_options --host=i686-pc-linux
+  ac_add_options --x-libraries=/usr/lib
+fi
diff --git a/build/unix/mozconfig.stdcxx b/build/unix/mozconfig.stdcxx
new file mode 100644
index 000000000..787e9b443
--- /dev/null
+++ b/build/unix/mozconfig.stdcxx
@@ -0,0 +1,15 @@
+# Avoid dependency on libstdc++ 4.7
+ac_add_options --enable-stdcxx-compat
+
+TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
+
+if [ -f "$TOOLTOOL_DIR/clang/lib/libstdc++.so" ]; then
+  LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOOLTOOL_DIR/clang/lib
+elif [ -f "$TOOLTOOL_DIR/gcc/lib/libstdc++.so" ]; then
+  # We put both 32-bits and 64-bits library path in LD_LIBRARY_PATH: ld.so
+  # will prefer the files in the 32-bits path when loading 32-bits executables,
+  # and the files in the 64-bits path when loading 64-bits executables.
+  LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOOLTOOL_DIR/gcc/lib64:$TOOLTOOL_DIR/gcc/lib
+fi
+
+mk_add_options "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
diff --git a/build/win32/mozconfig.vs-latest b/build/win32/mozconfig.vs-latest
new file mode 100644
index 000000000..9c8726a8d
--- /dev/null
+++ b/build/win32/mozconfig.vs-latest
@@ -0,0 +1 @@
+. $topsrcdir/build/win32/mozconfig.vs2015-win64
diff --git a/build/win32/mozconfig.vs2015-win64 b/build/win32/mozconfig.vs2015-win64
new file mode 100644
index 000000000..b81afa681
--- /dev/null
+++ b/build/win32/mozconfig.vs2015-win64
@@ -0,0 +1,25 @@
+if [ -z "${VSPATH}" ]; then
+    TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
+    VSPATH="$(cd ${TOOLTOOL_DIR} && pwd)/vs2015u3"
+fi
+
+VSWINPATH="$(cd ${VSPATH} && pwd -W)"
+
+export WINDOWSSDKDIR="${VSWINPATH}/SDK"
+export WIN32_REDIST_DIR="${VSPATH}/VC/redist/x86/Microsoft.VC140.CRT"
+export WIN_UCRT_REDIST_DIR="${VSPATH}/SDK/Redist/ucrt/DLLs/x86"
+
+export PATH="${VSPATH}/VC/bin/amd64_x86:${VSPATH}/VC/bin/amd64:${VSPATH}/VC/bin:${VSPATH}/SDK/bin/x86:${VSPATH}/SDK/bin/x64:${VSPATH}/DIA SDK/bin:${PATH}"
+export PATH="${VSPATH}/VC/redist/x86/Microsoft.VC140.CRT:${VSPATH}/VC/redist/x64/Microsoft.VC140.CRT:${VSPATH}/SDK/Redist/ucrt/DLLs/x86:${VSPATH}/SDK/Redist/ucrt/DLLs/x64:${PATH}"
+
+export INCLUDE="${VSPATH}/VC/include:${VSPATH}/VC/atlmfc/include:${VSPATH}/SDK/Include/10.0.14393.0/ucrt:${VSPATH}/SDK/Include/10.0.14393.0/shared:${VSPATH}/SDK/Include/10.0.14393.0/um:${VSPATH}/SDK/Include/10.0.14393.0/winrt:${VSPATH}/DIA SDK/include"
+export LIB="${VSPATH}/VC/lib:${VSPATH}/VC/atlmfc/lib:${VSPATH}/SDK/lib/10.0.14393.0/ucrt/x86:${VSPATH}/SDK/lib/10.0.14393.0/um/x86:${VSPATH}/DIA SDK/lib"
+
+. $topsrcdir/build/mozconfig.vs-common
+
+mk_export_correct_style WINDOWSSDKDIR
+mk_export_correct_style INCLUDE
+mk_export_correct_style LIB
+mk_export_correct_style PATH
+mk_export_correct_style WIN32_REDIST_DIR
+mk_export_correct_style WIN_UCRT_REDIST_DIR
diff --git a/build/win64/mozconfig.vs-latest b/build/win64/mozconfig.vs-latest
new file mode 100644
index 000000000..3470d4ace
--- /dev/null
+++ b/build/win64/mozconfig.vs-latest
@@ -0,0 +1 @@
+. $topsrcdir/build/win64/mozconfig.vs2015
diff --git a/build/win64/mozconfig.vs2015 b/build/win64/mozconfig.vs2015
new file mode 100644
index 000000000..e81a00064
--- /dev/null
+++ b/build/win64/mozconfig.vs2015
@@ -0,0 +1,24 @@
+if [ -z "${VSPATH}" ]; then
+    TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
+    VSPATH="$(cd ${TOOLTOOL_DIR} && pwd)/vs2015u3"
+fi
+
+VSWINPATH="$(cd ${VSPATH} && pwd -W)"
+
+export WINDOWSSDKDIR="${VSWINPATH}/SDK"
+export WIN32_REDIST_DIR=${VSPATH}/VC/redist/x64/Microsoft.VC140.CRT
+export WIN_UCRT_REDIST_DIR="${VSPATH}/SDK/Redist/ucrt/DLLs/x64"
+
+export PATH="${VSPATH}/VC/bin/amd64:${VSPATH}/VC/bin:${VSPATH}/SDK/bin/x64:${VSPATH}/VC/redist/x64/Microsoft.VC140.CRT:${VSPATH}/SDK/Redist/ucrt/DLLs/x64:${VSPATH}/DIA SDK/bin/amd64:${PATH}"
+
+export INCLUDE="${VSPATH}/VC/include:${VSPATH}/VC/atlmfc/include:${VSPATH}/SDK/Include/10.0.14393.0/ucrt:${VSPATH}/SDK/Include/10.0.14393.0/shared:${VSPATH}/SDK/Include/10.0.14393.0/um:${VSPATH}/SDK/Include/10.0.14393.0/winrt:${VSPATH}/DIA SDK/include"
+export LIB="${VSPATH}/VC/lib/amd64:${VSPATH}/VC/atlmfc/lib/amd64:${VSPATH}/SDK/lib/10.0.14393.0/ucrt/x64:${VSPATH}/SDK/lib/10.0.14393.0/um/x64:${VSPATH}/DIA SDK/lib/amd64"
+
+. $topsrcdir/build/mozconfig.vs-common
+
+mk_export_correct_style WINDOWSSDKDIR
+mk_export_correct_style INCLUDE
+mk_export_correct_style LIB
+mk_export_correct_style PATH
+mk_export_correct_style WIN32_REDIST_DIR
+mk_export_correct_style WIN_UCRT_REDIST_DIR