diff --git a/crypto777/tools/chrome.localhost b/crypto777/tools/chrome.localhost
new file mode 100755
index 000000000..3650f1e52
--- /dev/null
+++ b/crypto777/tools/chrome.localhost
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+OS=`uname -s`
+
+if [ $OS == Linux ]
+then
+  google-chrome --allow-nacl-socket-api=127.0.0.1
+else
+if [ $OS == Darwin ]
+then
+echo must be a mac
+open -a "Google Chrome" --args --allow-nacl-socket-api=127.0.0.1
+else
+"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" -allow-nacl-socket-api=127.0.0.1
+fi
+fi
+#open -a "Google Chrome" --args --allow-nacl-socket-api=127.0.0.1 --no-sandbox
+#open -a "Google Chrome" --args --allow-nacl-socket-api=commondatastorage.googleapis.com --no-sandbox
+#"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" -allow-nacl-socket-api=localhost
diff --git a/crypto777/tools/chrome.localhost.bat b/crypto777/tools/chrome.localhost.bat
new file mode 100644
index 000000000..51e55c536
--- /dev/null
+++ b/crypto777/tools/chrome.localhost.bat
@@ -0,0 +1,5 @@
+SET KEY_NAME=HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe
+FOR /F "skip=2 tokens=2,*" %%A IN ('reg query "%KEY_NAME%" /ve') DO set "CHROME_PATH=%%B"
+REM echo %CHROME_PATH%
+
+"%CHROME_PATH%" -allow-nacl-socket-api=localhost
\ No newline at end of file
diff --git a/crypto777/tools/common.mk b/crypto777/tools/common.mk
new file mode 100644
index 000000000..922b289b0
--- /dev/null
+++ b/crypto777/tools/common.mk
@@ -0,0 +1,547 @@
+# Copyrigh t (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+#
+# GNU Make based build file.  For details on GNU Make see:
+#   http://www.gnu.org/software/make/manual/make.html
+#
+
+#
+# Toolchain
+#
+# By default the VALID_TOOLCHAINS list contains pnacl, newlib and glibc.  If
+# your project only builds in one or the other then this should be overridden
+# accordingly.
+#
+ifneq ($(ENABLE_BIONIC),)
+ALL_TOOLCHAINS ?= pnacl newlib glibc clang-newlib bionic
+else
+ALL_TOOLCHAINS ?= pnacl newlib glibc clang-newlib
+endif
+
+VALID_TOOLCHAINS ?= $(ALL_TOOLCHAINS)
+TOOLCHAIN ?= $(word 1,$(VALID_TOOLCHAINS))
+
+#
+# Top Make file, which we want to trigger a rebuild on if it changes
+#
+TOP_MAKE := $(word 1,$(MAKEFILE_LIST))
+
+
+#
+# Figure out which OS we are running on.
+#
+GETOS := python $(NACL_SDK_ROOT)/tools/getos.py
+NACL_CONFIG := python $(NACL_SDK_ROOT)/tools/nacl_config.py
+FIXDEPS := python $(NACL_SDK_ROOT)/tools/fix_deps.py -c
+OSNAME := $(shell $(GETOS))
+
+
+#
+# TOOLCHAIN=all recursively calls this Makefile for all VALID_TOOLCHAINS.
+#
+ifeq ($(TOOLCHAIN),all)
+
+# Define the default target
+all:
+
+#
+# Generate a new MAKE command for each TOOLCHAIN.
+#
+# Note: We use targets for each toolchain (instead of an explicit recipe) so
+# each toolchain can be built in parallel.
+#
+# $1 = Toolchain Name
+#
+define TOOLCHAIN_RULE
+TOOLCHAIN_TARGETS += $(1)_TARGET
+.PHONY: $(1)_TARGET
+$(1)_TARGET:
+	+$(MAKE) TOOLCHAIN=$(1) $(MAKECMDGOALS)
+endef
+
+#
+# The target for all versions
+#
+USABLE_TOOLCHAINS=$(filter $(OSNAME) $(ALL_TOOLCHAINS),$(VALID_TOOLCHAINS))
+
+ifeq ($(NO_HOST_BUILDS),1)
+USABLE_TOOLCHAINS:=$(filter-out $(OSNAME),$(USABLE_TOOLCHAINS))
+endif
+
+# Define the toolchain targets for all usable toolchains via the macro.
+$(foreach tool,$(USABLE_TOOLCHAINS),$(eval $(call TOOLCHAIN_RULE,$(tool))))
+
+.PHONY: all clean install
+all: $(TOOLCHAIN_TARGETS)
+clean: $(TOOLCHAIN_TARGETS)
+install: $(TOOLCHAIN_TARGETS)
+
+else  # TOOLCHAIN=all
+
+#
+# Verify we selected a valid toolchain for this example
+#
+ifeq (,$(findstring $(TOOLCHAIN),$(VALID_TOOLCHAINS)))
+
+# Only fail to build if this is a top-level make. When building recursively, we
+# don't care if an example can't build with this toolchain.
+ifeq ($(MAKELEVEL),0)
+  $(warning Availbile choices are: $(VALID_TOOLCHAINS))
+  $(error Can not use TOOLCHAIN=$(TOOLCHAIN) on this example.)
+else
+
+# Dummy targets for recursive make with unsupported toolchain...
+.PHONY: all clean install
+all:
+clean:
+install:
+
+endif
+
+else  # TOOLCHAIN is valid...
+
+#
+# Build Configuration
+#
+# The SDK provides two sets of libraries, Debug and Release.  Debug libraries
+# are compiled without optimizations to make debugging easier.  By default
+# this will build a Release configuration. When debugging via "make debug",
+# build the debug configuration by default instead.
+#
+ifneq (,$(findstring debug,$(MAKECMDGOALS)))
+CONFIG ?= Debug
+else
+CONFIG ?= Release
+endif
+
+
+#
+# Verify we selected a valid configuration for this example.
+#
+VALID_CONFIGS ?= Debug Release
+ifeq (,$(findstring $(CONFIG),$(VALID_CONFIGS)))
+  $(warning Availbile choices are: $(VALID_CONFIGS))
+  $(error Can not use CONFIG=$(CONFIG) on this example.)
+endif
+
+
+#
+# Note for Windows:
+#   The GCC and LLVM toolchains (include the version of Make.exe that comes
+# with the SDK) expect and are capable of dealing with the '/' seperator.
+# For this reason, the tools in the SDK, including Makefiles and build scripts
+# have a preference for POSIX style command-line arguments.
+#
+# Keep in mind however that the shell is responsible for command-line escaping,
+# globbing, and variable expansion, so those may change based on which shell
+# is used.  For Cygwin shells this can include automatic and incorrect expansion
+# of response files (files starting with '@').
+#
+# Disable DOS PATH warning when using Cygwin based NaCl tools on Windows.
+#
+ifeq ($(OSNAME),win)
+  # Always use cmd.exe as the shell on Windows. Otherwise Make may try to
+  # search the path for sh.exe. If it is found in a path with a space, the
+  # command will fail.
+  SHELL := cmd.exe
+  CYGWIN ?= nodosfilewarning
+  export CYGWIN
+endif
+
+
+#
+# If NACL_SDK_ROOT is not already set, then set it relative to this makefile.
+#
+THIS_MAKEFILE := $(CURDIR)/$(lastword $(MAKEFILE_LIST))
+NACL_SDK_ROOT ?= $(realpath $(dir $(THIS_MAKEFILE))/..)
+
+
+#
+# Check that NACL_SDK_ROOT is set to a valid location.
+# We use the existence of tools/oshelpers.py to verify the validity of the SDK
+# root.
+#
+ifeq (,$(wildcard $(NACL_SDK_ROOT)/tools/oshelpers.py))
+  $(error NACL_SDK_ROOT is set to an invalid location: $(NACL_SDK_ROOT))
+endif
+
+
+#
+# If this makefile is part of a valid nacl SDK, but NACL_SDK_ROOT is set
+# to a different location this is almost certainly a local configuration
+# error.
+#
+LOCAL_ROOT := $(realpath $(dir $(THIS_MAKEFILE))/..)
+ifneq (,$(wildcard $(LOCAL_ROOT)/tools/oshelpers.py))
+  ifneq ($(realpath $(NACL_SDK_ROOT)), $(realpath $(LOCAL_ROOT)))
+    $(error common.mk included from an SDK that does not match the current NACL_SDK_ROOT)
+  endif
+endif
+
+
+#
+# Alias for standard POSIX file system commands
+#
+OSHELPERS = python $(NACL_SDK_ROOT)/tools/oshelpers.py
+WHICH := $(OSHELPERS) which
+ifdef V
+RM := $(OSHELPERS) rm
+CP := $(OSHELPERS) cp
+MKDIR := $(OSHELPERS) mkdir
+MV := $(OSHELPERS) mv
+else
+RM := @$(OSHELPERS) rm
+CP := @$(OSHELPERS) cp
+MKDIR := @$(OSHELPERS) mkdir
+MV := @$(OSHELPERS) mv
+endif
+
+
+
+#
+# Compute path to requested NaCl Toolchain
+#
+TC_PATH := $(abspath $(NACL_SDK_ROOT)/../toolchain)
+
+
+#
+# Check for required minimum SDK version.
+# A makefile can declare NACL_SDK_VERSION_MIN of the form "<major>.<position>",
+# where <major> is the major Chromium version number, and <position> is the
+# Chromium Cr-Commit-Position number. eg. "39.295386".
+#
+ifdef NACL_SDK_VERSION_MIN
+  VERSION_CHECK:=$(shell $(GETOS) --check-version=$(NACL_SDK_VERSION_MIN) 2>&1)
+  ifneq ($(VERSION_CHECK),)
+    $(error $(VERSION_CHECK))
+  endif
+endif
+
+
+#
+# The default target
+#
+# If no targets are specified on the command-line, the first target listed in
+# the makefile becomes the default target.  By convention this is usually called
+# the 'all' target.  Here we leave it blank to be first, but define it later
+#
+all:
+.PHONY: all
+
+
+#
+# The install target is used to install built libraries to thier final destination.
+# By default this is the NaCl SDK 'lib' folder.
+#
+install:
+.PHONY: install
+
+ifdef SEL_LDR
+STANDALONE = 1
+endif
+
+OUTBASE ?= .
+ifdef STANDALONE
+OUTDIR := $(OUTBASE)/$(TOOLCHAIN)/standalone_$(CONFIG)
+else
+OUTDIR := $(OUTBASE)/$(TOOLCHAIN)/$(CONFIG)
+endif
+STAMPDIR ?= $(OUTDIR)
+LIBDIR ?= $(NACL_SDK_ROOT)/lib
+
+
+#
+# Target to remove temporary files
+#
+.PHONY: clean
+clean:
+	$(RM) -f $(TARGET).nmf
+	$(RM) -rf $(OUTDIR)
+	$(RM) -rf user-data-dir
+	mkdir pnacl; mkdir pnacl/Release
+	cp Release/* nacl_io.stamp pnacl/Release; 
+
+
+#
+# Rules for output directories.
+#
+# Output will be places in a directory name based on Toolchain and configuration
+# be default this will be "newlib/Debug".  We use a python wrapped MKDIR to
+# proivde a cross platform solution. The use of '|' checks for existance instead
+# of timestamp, since the directory can update when files change.
+#
+%dir.stamp :
+	$(MKDIR) -p $(dir $@)
+	@echo Directory Stamp > $@
+
+
+#
+# Dependency Macro
+#
+# $1 = Name of stamp
+# $2 = Directory for the sub-make
+# $3 = Extra Settings
+#
+define DEPEND_RULE
+ifndef IGNORE_DEPS
+.PHONY: rebuild_$(1)
+
+rebuild_$(1) :| $(STAMPDIR)/dir.stamp
+ifeq (,$(2))
+	+$(MAKE) -C $(NACL_SDK_ROOT)/src/$(1) STAMPDIR=$(abspath $(STAMPDIR)) $(abspath $(STAMPDIR)/$(1).stamp) $(3)
+else
+	+$(MAKE) -C $(2) STAMPDIR=$(abspath $(STAMPDIR)) $(abspath $(STAMPDIR)/$(1).stamp) $(3)
+endif
+	cp pnacl/Release/*.pexe pnacl/Release/*.bc pnacl/Release/SuperNET_API.nmf Release
+
+all: rebuild_$(1)
+$(STAMPDIR)/$(1).stamp: rebuild_$(1)
+
+else
+
+.PHONY: $(STAMPDIR)/$(1).stamp
+$(STAMPDIR)/$(1).stamp:
+	@echo Ignore $(1)
+endif
+endef
+
+ifeq ($(TOOLCHAIN),win)
+ifdef STANDALONE
+HOST_EXT = .exe
+else
+HOST_EXT = .dll
+endif
+else
+ifdef STANDALONE
+HOST_EXT =
+else
+HOST_EXT = .so
+endif
+endif
+
+
+#
+# Common Compile Options
+#
+# For example, -DNDEBUG is added to release builds by default
+# so that calls to assert(3) are not included in the build.
+#
+ifeq ($(CONFIG),Release)
+POSIX_CFLAGS ?= -g -O2 -pthread -MMD -DNDEBUG
+NACL_LDFLAGS ?= -O2
+PNACL_LDFLAGS ?= -O2
+else
+POSIX_CFLAGS ?= -g -O0 -pthread -MMD -DNACL_SDK_DEBUG
+endif
+
+NACL_CFLAGS ?= -Wno-long-long -Werror
+NACL_CXXFLAGS ?= -Wno-long-long -Werror
+NACL_LDFLAGS += -Wl,-as-needed -pthread
+
+#
+# Default Paths
+#
+INC_PATHS := $(shell $(NACL_CONFIG) -t $(TOOLCHAIN) --include-dirs) $(EXTRA_INC_PATHS)
+LIB_PATHS := $(NACL_SDK_ROOT)/lib $(EXTRA_LIB_PATHS)
+
+#
+# Define a LOG macro that allow a command to be run in quiet mode where
+# the command echoed is not the same as the actual command executed.
+# The primary use case for this is to avoid echoing the full compiler
+# and linker command in the default case.  Defining V=1 will restore
+# the verbose behavior
+#
+# $1 = The name of the tool being run
+# $2 = The target file being built
+# $3 = The full command to run
+#
+ifdef V
+define LOG
+$(3)
+endef
+else
+ifeq ($(OSNAME),win)
+define LOG
+@echo   $(1) $(2) && $(3)
+endef
+else
+define LOG
+@echo "  $(1) $(2)" && $(3)
+endef
+endif
+endif
+
+
+#
+# Convert a source path to a object file path.
+#
+# $1 = Source Name
+# $2 = Arch suffix
+#
+define SRC_TO_OBJ
+$(OUTDIR)/$(basename $(subst ..,__,$(1)))$(2).o
+endef
+
+
+#
+# Convert a source path to a dependency file path.
+# We use the .deps extension for dependencies.  These files are generated by
+# fix_deps.py based on the .d files which gcc generates.  We don't reference
+# the .d files directly so that we can avoid the the case where the compile
+# failed but still generated a .d file (in that case the .d file would not
+# be processed by fix_deps.py)
+#
+# $1 = Source Name
+# $2 = Arch suffix
+#
+define SRC_TO_DEP
+$(patsubst %.o,%.deps,$(call SRC_TO_OBJ,$(1),$(2)))
+endef
+
+#
+# The gcc-generated deps files end in .d
+#
+define SRC_TO_DEP_PRE_FIXUP
+$(patsubst %.o,%.d,$(call SRC_TO_OBJ,$(1),$(2)))
+endef
+
+
+#
+# If the requested toolchain is a NaCl or PNaCl toolchain, the use the
+# macros and targets defined in nacl.mk, otherwise use the host sepecific
+# macros and targets.
+#
+ifneq (,$(findstring $(TOOLCHAIN),linux mac))
+include $(NACL_SDK_ROOT)/tools/host_gcc.mk
+endif
+
+ifneq (,$(findstring $(TOOLCHAIN),win))
+include $(NACL_SDK_ROOT)/tools/host_vc.mk
+endif
+
+ifneq (,$(findstring $(TOOLCHAIN),glibc newlib bionic clang-newlib))
+include $(NACL_SDK_ROOT)/tools/nacl_gcc.mk
+endif
+
+ifneq (,$(findstring $(TOOLCHAIN),pnacl))
+include $(NACL_SDK_ROOT)/tools/nacl_llvm.mk
+endif
+
+#
+# File to redirect to to in order to hide output.
+#
+ifeq ($(OSNAME),win)
+DEV_NULL = nul
+else
+DEV_NULL = /dev/null
+endif
+
+
+#
+# Variables for running examples with Chrome.
+#
+RUN_PY := python $(NACL_SDK_ROOT)/tools/run.py
+#HTTPD_PY := python $(NACL_SDK_ROOT)/tools/httpd.py
+HTTPD_PY := python tools/httpd.py
+
+# Add this to launch Chrome with additional environment variables defined.
+# Each element should be specified as KEY=VALUE, with whitespace separating
+# key-value pairs. e.g.
+# CHROME_ENV=FOO=1 BAR=2 BAZ=3
+CHROME_ENV ?=
+
+# Additional arguments to pass to Chrome.
+CHROME_ARGS += --enable-nacl --enable-pnacl --no-first-run
+CHROME_ARGS += --user-data-dir=$(CURDIR)/user-data-dir
+
+
+# Paths to Debug and Release versions of the Host Pepper plugins
+PPAPI_DEBUG = $(abspath $(OSNAME)/Debug/$(TARGET)$(HOST_EXT));application/x-ppapi-debug
+PPAPI_RELEASE = $(abspath $(OSNAME)/Release/$(TARGET)$(HOST_EXT));application/x-ppapi-release
+
+
+SYSARCH := $(shell $(GETOS) --nacl-arch)
+SEL_LDR_PATH := python $(NACL_SDK_ROOT)/tools/sel_ldr.py
+
+#
+# Common Compile Options
+#
+ifeq ($(CONFIG),Debug)
+SEL_LDR_ARGS += --debug-libs
+endif
+
+ifndef STANDALONE
+#
+# Assign a sensible default to CHROME_PATH.
+#
+CHROME_PATH ?= $(shell $(GETOS) --chrome 2> $(DEV_NULL))
+
+#
+# Verify we can find the Chrome executable if we need to launch it.
+#
+
+NULL :=
+SPACE := $(NULL) # one space after NULL is required
+CHROME_PATH_ESCAPE := $(subst $(SPACE),\ ,$(CHROME_PATH))
+
+ifeq ($(OSNAME),win)
+  SANDBOX_ARGS := --no-sandbox
+endif
+
+GDB_PATH := $(shell $(NACL_CONFIG) -t $(TOOLCHAIN) --tool=gdb)
+
+.PHONY: check_for_chrome
+check_for_chrome:
+ifeq (,$(wildcard $(CHROME_PATH_ESCAPE)))
+	$(warning No valid Chrome found at CHROME_PATH=$(CHROME_PATH))
+	$(error Set CHROME_PATH via an environment variable, or command-line.)
+else
+	$(warning Using chrome at: $(CHROME_PATH))
+endif
+PAGE ?= index.html
+PAGE_TC_CONFIG ?= "$(PAGE)?tc=$(TOOLCHAIN)&config=$(CONFIG)"
+
+.PHONY: run
+run: check_for_chrome all $(PAGE)
+	$(RUN_PY) -C $(CURDIR) -P $(PAGE_TC_CONFIG) \
+	    $(addprefix -E ,$(CHROME_ENV)) -- "$(CHROME_PATH)" \
+	    $(CHROME_ARGS) \
+	    --register-pepper-plugins="$(PPAPI_DEBUG),$(PPAPI_RELEASE)"
+
+.PHONY: run_package
+run_package: check_for_chrome all
+	@echo "$(TOOLCHAIN) $(CONFIG)" > $(CURDIR)/run_package_config
+	"$(CHROME_PATH)" --load-and-launch-app=$(CURDIR) $(CHROME_ARGS)
+
+GDB_ARGS += -D $(GDB_PATH)
+# PNaCl's nexe is acquired with "remote get nexe <path>" instead of the NMF.
+ifeq (,$(findstring $(TOOLCHAIN),pnacl))
+GDB_ARGS += -D --eval-command="nacl-manifest $(abspath $(OUTDIR))/$(TARGET).nmf"
+GDB_ARGS += -D $(GDB_DEBUG_TARGET)
+endif
+
+.PHONY: debug
+debug: check_for_chrome all $(PAGE)
+	$(RUN_PY) $(GDB_ARGS) \
+	    -C $(CURDIR) -P $(PAGE_TC_CONFIG) \
+	    $(addprefix -E ,$(CHROME_ENV)) -- "$(CHROME_PATH)" \
+	    $(CHROME_ARGS) $(SANDBOX_ARGS) --enable-nacl-debug \
+	    --register-pepper-plugins="$(PPAPI_DEBUG),$(PPAPI_RELEASE)"
+
+.PHONY: serve
+serve: all
+	echo run tools/httpd.py
+endif
+
+# uppercase aliases (for backward compatibility)
+.PHONY: CHECK_FOR_CHROME DEBUG LAUNCH RUN
+CHECK_FOR_CHROME: check_for_chrome
+DEBUG: debug
+LAUNCH: run
+RUN: run
+
+endif  # TOOLCHAIN is valid...
+
+endif  # TOOLCHAIN=all
diff --git a/crypto777/tools/getos.py b/crypto777/tools/getos.py
new file mode 100755
index 000000000..c5fe5c2e7
--- /dev/null
+++ b/crypto777/tools/getos.py
@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Determine OS and various other system properties.
+
+Determine the name of the platform used and other system properties such as
+the location of Chrome.  This is used, for example, to determine the correct
+Toolchain to invoke.
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+
+import oshelpers
+
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+CHROME_DEFAULT_PATH = {
+  'win': r'c:\Program Files (x86)\Google\Chrome\Application\chrome.exe',
+  'mac': '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  'linux': '/usr/bin/google-chrome',
+}
+
+
+if sys.version_info < (2, 7, 0):
+  sys.stderr.write("python 2.7 or later is required run this script\n")
+  sys.exit(1)
+
+
+class Error(Exception):
+  pass
+
+
+def GetSDKPath():
+  return os.getenv('NACL_SDK_ROOT', os.path.dirname(SCRIPT_DIR))
+
+
+def GetPlatform():
+  if sys.platform.startswith('cygwin') or sys.platform.startswith('win'):
+    return 'win'
+  elif sys.platform.startswith('darwin'):
+    return 'mac'
+  elif sys.platform.startswith('linux'):
+    return 'linux'
+  else:
+    raise Error("Unknown platform: %s" % sys.platform)
+
+
+def UseWin64():
+  arch32 = os.environ.get('PROCESSOR_ARCHITECTURE')
+  arch64 = os.environ.get('PROCESSOR_ARCHITEW6432')
+
+  if arch32 == 'AMD64' or arch64 == 'AMD64':
+    return True
+  return False
+
+
+def GetSDKVersion():
+  root = GetSDKPath()
+  readme = os.path.join(root, "README")
+  if not os.path.exists(readme):
+    raise Error("README not found in SDK root: %s" % root)
+
+  version = None
+  revision = None
+  commit_position = None
+  for line in open(readme):
+    if ':' in line:
+      name, value = line.split(':', 1)
+      if name == "Version":
+        version = value.strip()
+      if name == "Chrome Revision":
+        revision = value.strip()
+      if name == "Chrome Commit Position":
+        commit_position = value.strip()
+
+  if revision is None or version is None or commit_position is None:
+    raise Error("error parsing SDK README: %s" % readme)
+
+  try:
+    version = int(version)
+    revision = int(revision)
+  except ValueError:
+    raise Error("error parsing SDK README: %s" % readme)
+
+  return (version, revision, commit_position)
+
+
+def GetSystemArch(platform):
+  if platform == 'win':
+    if UseWin64():
+      return 'x86_64'
+    return 'x86_32'
+
+  if platform in ['mac', 'linux']:
+    try:
+      pobj = subprocess.Popen(['uname', '-m'], stdout= subprocess.PIPE)
+      arch = pobj.communicate()[0]
+      arch = arch.split()[0]
+      if arch.startswith('arm'):
+        arch = 'arm'
+    except Exception:
+      arch = None
+  return arch
+
+
+def GetChromePath(platform):
+  # If CHROME_PATH is defined and exists, use that.
+  chrome_path = os.environ.get('CHROME_PATH')
+  if chrome_path:
+    if not os.path.exists(chrome_path):
+      raise Error('Invalid CHROME_PATH: %s' % chrome_path)
+    return os.path.realpath(chrome_path)
+
+  # Otherwise look in the PATH environment variable.
+  basename = os.path.basename(CHROME_DEFAULT_PATH[platform])
+  chrome_path = oshelpers.FindExeInPath(basename)
+  if chrome_path:
+    return os.path.realpath(chrome_path)
+
+  # Finally, try the default paths to Chrome.
+  chrome_path = CHROME_DEFAULT_PATH[platform]
+  if os.path.exists(chrome_path):
+    return os.path.realpath(chrome_path)
+
+  raise Error('CHROME_PATH is undefined, and %s not found in PATH, nor %s.' % (
+              basename, chrome_path))
+
+
+def GetNaClArch(platform):
+  if platform == 'win':
+    # On windows the nacl arch always matches to system arch
+    return GetSystemArch(platform)
+  elif platform == 'mac':
+    # On Mac the nacl arch is currently always 32-bit.
+    return 'x86_32'
+
+  # On linux the nacl arch matches to chrome arch, so we inspect the chrome
+  # binary using objdump
+  chrome_path = GetChromePath(platform)
+
+  # If CHROME_PATH is set to point to google-chrome or google-chrome
+  # was found in the PATH and we are running on UNIX then google-chrome
+  # is a bash script that points to 'chrome' in the same folder.
+  #
+  # When running beta or dev branch, the name is google-chrome-{beta,dev}.
+  if os.path.basename(chrome_path).startswith('google-chrome'):
+    chrome_path = os.path.join(os.path.dirname(chrome_path), 'chrome')
+
+  if not os.path.exists(chrome_path):
+    raise Error("File %s does not exist." % chrome_path)
+
+  if not os.access(chrome_path, os.X_OK):
+    raise Error("File %s is not executable" % chrome_path)
+
+  try:
+    pobj = subprocess.Popen(['objdump', '-f', chrome_path],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+    output, stderr = pobj.communicate()
+    # error out here if objdump failed
+    if pobj.returncode:
+      raise Error(output + stderr.strip())
+  except OSError as e:
+    # This will happen if objdump is not installed
+    raise Error("Error running objdump: %s" % e)
+
+  pattern = r'(file format) ([a-zA-Z0-9_\-]+)'
+  match = re.search(pattern, output)
+  if not match:
+    raise Error("Error running objdump on: %s" % chrome_path)
+
+  arch = match.group(2)
+  if 'arm' in arch:
+    return 'arm'
+  if '64' in arch:
+    return 'x86_64'
+  return 'x86_32'
+
+
+def ParseVersion(version):
+  """Parses a version number of the form '<major>.<position>'.
+
+  <position> is the Cr-Commit-Position number.
+  """
+  if '.' in version:
+    version = version.split('.')
+  else:
+    version = (version, '0')
+
+  try:
+    return tuple(int(x) for x in version)
+  except ValueError:
+    raise Error('error parsing SDK version: %s' % version)
+
+
+def CheckVersion(required_version):
+  """Determines whether the current SDK version meets the required version.
+
+  Args:
+    required_version: (major, position) pair, where position is the
+    Cr-Commit-Position number.
+
+  Raises:
+    Error: The SDK version is older than required_version.
+  """
+  version = GetSDKVersion()[:2]
+  if version < required_version:
+    raise Error("SDK version too old (current: %d.%d, required: %d.%d)"
+           % (version[0], version[1], required_version[0], required_version[1]))
+
+
+def main(args):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--arch', action='store_true',
+      help='Print architecture of current machine (x86_32, x86_64 or arm).')
+  parser.add_argument('--chrome', action='store_true',
+      help='Print the path chrome (by first looking in $CHROME_PATH and '
+           'then $PATH).')
+  parser.add_argument('--nacl-arch', action='store_true',
+      help='Print architecture used by NaCl on the current machine.')
+  parser.add_argument('--sdk-version', action='store_true',
+      help='Print major version of the NaCl SDK.')
+  parser.add_argument('--sdk-revision', action='store_true',
+      help='Print revision number of the NaCl SDK.')
+  parser.add_argument('--sdk-commit-position', action='store_true',
+      help='Print commit position of the NaCl SDK.')
+  parser.add_argument('--check-version',
+      metavar='MAJOR.POSITION',
+      help='Check that the SDK version is at least as great as the '
+           'version passed in. MAJOR is the major version number and POSITION '
+           'is the Cr-Commit-Position number.')
+
+  if len(args) > 1:
+    parser.error('Only one option can be specified at a time.')
+
+  options = parser.parse_args(args)
+
+  platform = GetPlatform()
+
+  if options.arch:
+    out = GetSystemArch(platform)
+  elif options.nacl_arch:
+    out = GetNaClArch(platform)
+  elif options.chrome:
+    out = GetChromePath(platform)
+  elif options.sdk_version:
+    out = GetSDKVersion()[0]
+  elif options.sdk_revision:
+    out = GetSDKVersion()[1]
+  elif options.sdk_commit_position:
+    out = GetSDKVersion()[2]
+  elif options.check_version:
+    required_version = ParseVersion(options.check_version)
+    CheckVersion(required_version)
+    out = None
+  else:
+    out = platform
+
+  if out:
+    print out
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except Error as e:
+    sys.stderr.write(str(e) + '\n')
+    sys.exit(1)
diff --git a/crypto777/tools/httpd.py b/crypto777/tools/httpd.py
new file mode 100755
index 000000000..644bfadc6
--- /dev/null
+++ b/crypto777/tools/httpd.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import argparse
+import logging
+import multiprocessing
+import os
+import socket
+import sys
+import time
+
+if sys.version_info < (2, 7, 0):
+  sys.stderr.write("python 2.7 or later is required run this script\n")
+  sys.exit(1)
+
+try:
+  # Python 3+
+  from http.server import HTTPServer, SimpleHTTPRequestHandler
+  from urllib.parse import urlparse, parse_qs, urlsplit
+except ImportError:
+  # Python 2.7
+  from urlparse import urlparse, urlsplit, parse_qs
+  from BaseHTTPServer import HTTPServer
+  from SimpleHTTPServer import SimpleHTTPRequestHandler
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+NACL_SDK_ROOT = os.path.dirname(SCRIPT_DIR)
+
+# We only run from the examples directory so that not too much is exposed
+# via this HTTP server.  Everything in the directory is served, so there should
+# never be anything potentially sensitive in the serving directory, especially
+# if the machine might be a multi-user machine and not all users are trusted.
+# We only serve via the loopback interface.
+def SanityCheckDirectory(dirname):
+  abs_serve_dir = os.path.abspath(dirname)
+
+  # Verify we don't serve anywhere above NACL_SDK_ROOT.
+  if abs_serve_dir[:len(NACL_SDK_ROOT)] == NACL_SDK_ROOT:
+    return
+  logging.error('For security, httpd.py should only be run from within the')
+  logging.error('example directory tree.')
+  logging.error('Attempting to serve from %s.' % abs_serve_dir)
+  logging.error('Run with --no-dir-check to bypass this check.')
+  sys.exit(1)
+
+
+class SuperNetHTTPServer(HTTPServer):
+  def __init__(self, *args, **kwargs):
+    HTTPServer.__init__(self, *args)
+    self.running = True
+    self.result = 0
+
+  def Shutdown(self, result=0):
+    self.running = False
+    self.result = result
+
+
+class SuperNetHTTPRequestHandler(SimpleHTTPRequestHandler):
+  def _SendNothingAndDie(self, result=0):
+    self.send_response(200, 'OK')
+    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-length', '0')
+    self.end_headers()
+    self.server.Shutdown(result)
+
+  def do_GET(self):
+    # Browsing to ?quit=1 will kill the server cleanly.
+    _, _, _, query, _ = urlsplit(self.path)
+    if query:
+      params = parse_qs(query)
+      if '1' in params.get('quit', []):
+        self._SendNothingAndDie()
+        return
+
+    return SimpleHTTPRequestHandler.do_GET(self)
+
+
+class LocalHTTPServer(object):
+  """Class to start a local HTTP server as a child process."""
+
+  def __init__(self, dirname, port):
+    parent_conn, child_conn = multiprocessing.Pipe()
+    self.process = multiprocessing.Process(
+        target=_HTTPServerProcess,
+        args=(child_conn, dirname, port, {}))
+    self.process.start()
+    if parent_conn.poll(10):  # wait 10 seconds
+      self.port = parent_conn.recv()
+    else:
+      raise Exception('Unable to launch HTTP server.')
+
+    self.conn = parent_conn
+
+  def ServeForever(self):
+    """Serve until the child HTTP process tells us to stop.
+
+    Returns:
+      The result from the child (as an errorcode), or 0 if the server was
+      killed not by the child (by KeyboardInterrupt for example).
+    """
+    child_result = 0
+    try:
+      # Block on this pipe, waiting for a response from the child process.
+      child_result = self.conn.recv()
+    except KeyboardInterrupt:
+      pass
+    finally:
+      self.Shutdown()
+    return child_result
+
+  def ServeUntilSubprocessDies(self, process):
+    """Serve until the child HTTP process tells us to stop or |subprocess| dies.
+
+    Returns:
+      The result from the child (as an errorcode), or 0 if |subprocess| died,
+      or the server was killed some other way (by KeyboardInterrupt for
+      example).
+    """
+    child_result = 0
+    try:
+      while True:
+        if process.poll() is not None:
+          child_result = 0
+          break
+        if self.conn.poll():
+          child_result = self.conn.recv()
+          break
+        time.sleep(0)
+    except KeyboardInterrupt:
+      pass
+    finally:	  
+      self.Shutdown()
+    return child_result
+
+  def Shutdown(self):
+    """Send a message to the child HTTP server process and wait for it to
+        finish."""
+    print("Shutting down server")
+    self.conn.send(False)
+    self.process.join()
+
+  def GetURL(self, rel_url):
+    """Get the full url for a file on the local HTTP server.
+
+    Args:
+      rel_url: A URL fragment to convert to a full URL. For example,
+          GetURL('foobar.baz') -> 'http://127.0.0.1:1234/foobar.baz'
+    """
+    return 'http://127.0.0.1:%d/%s' % (self.port, rel_url)
+
+
+def _HTTPServerProcess(conn, dirname, port, server_kwargs):
+  """Run a local httpserver with the given port or an ephemeral port.
+
+  This function assumes it is run as a child process using multiprocessing.
+
+  Args:
+    conn: A connection to the parent process. The child process sends
+        the local port, and waits for a message from the parent to
+        stop serving. It also sends a "result" back to the parent -- this can
+        be used to allow a client-side test to notify the server of results.
+    dirname: The directory to serve. All files are accessible through
+       http://127.0.0.1:<port>/path/to/filename.
+    port: The port to serve on. If 0, an ephemeral port will be chosen.
+    server_kwargs: A dict that will be passed as kwargs to the server.
+  """
+  try:
+    os.chdir(dirname)
+    httpd = SuperNetHTTPServer(('', port), SuperNetHTTPRequestHandler, **server_kwargs)
+  except socket.error as e:
+    sys.stderr.write('Error creating SuperNetHTTPServer: %s\n' % e)
+    sys.exit(1)
+
+  try:
+    conn.send(httpd.server_address[1])  # the chosen port number
+    httpd.timeout = 0.5  # seconds
+    while httpd.running:
+      # Flush output for MSVS Add-In.
+      sys.stdout.flush()
+      sys.stderr.flush()
+      httpd.handle_request()
+      if conn.poll():
+        httpd.running = conn.recv()
+  except KeyboardInterrupt:
+    pass
+  finally:
+    conn.send(httpd.result)
+    conn.close()
+
+
+def main(args):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('-C', '--serve-dir',
+      help='Serve files out of this directory.',
+      default=os.path.abspath('.'))
+  parser.add_argument('-p', '--port',
+      help='Run server on this port.', default=7777)
+  parser.add_argument('--no-dir-check', '--no_dir_check',
+      help='No check to ensure serving from safe directory.',
+      dest='do_safe_check', action='store_false', default=True)
+
+  # To enable bash completion for this command first install optcomplete
+  # and then add this line to your .bashrc:
+  #  complete -F _optcomplete httpd.py
+  try:
+    import optcomplete
+    optcomplete.autocomplete(parser)
+  except ImportError:
+    pass
+
+  options = parser.parse_args(args)
+  if options.do_safe_check:
+    SanityCheckDirectory(options.serve_dir)
+
+  server = LocalHTTPServer(options.serve_dir, int(options.port))
+
+  # Serve until the client tells us to stop. When it does, it will give us an
+  # errorcode.
+  print(('Serving {0} on {1}...'.format(options.serve_dir, server.GetURL(''))))
+  return server.ServeForever()
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))
diff --git a/crypto777/tools/run.bat b/crypto777/tools/run.bat
new file mode 100644
index 000000000..6e32859a8
--- /dev/null
+++ b/crypto777/tools/run.bat
@@ -0,0 +1,3 @@
+@echo OFF
+call chrome.localhost.bat
+python tools\httpd.py -p 7777
\ No newline at end of file