Cleaned up directory after copy of tools from perforce directory

Got rid of stale copies of some tools like "crosperf" and moved all
files under v14 directory (that came from perforce) into the top
directory.

BUG=None
TEST=None

Change-Id: I408d17a36ceb00e74db71403d2351fd466a14f8e
Reviewed-on: https://gerrit-int.chromium.org/33887
Tested-by: Luis Lozano <llozano@chromium.org>
Reviewed-by: Yunlian Jiang <yunlian@google.com>
Commit-Queue: Luis Lozano <llozano@chromium.org>

205 files changed, 465 insertions, 13003 deletions

diff --git a/v14/.gitignore b/.gitignore
index d0b39e30..d0b39e30 100644
--- a/v14/.gitignore
+++ b/.gitignore
diff --git a/v14/automation/PRESUBMIT.py b/automation/PRESUBMIT.py
index 56a43e6c..56a43e6c 100644
--- a/v14/automation/PRESUBMIT.py
+++ b/automation/PRESUBMIT.py
diff --git a/v14/automation/__init__.py b/automation/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/__init__.py
+++ b/automation/__init__.py
diff --git a/v14/automation/all_tests.py b/automation/all_tests.py
index 3ca4f52a..3ca4f52a 100644
--- a/v14/automation/all_tests.py
+++ b/automation/all_tests.py
diff --git a/v14/automation/clients/__init__.py b/automation/clients/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/clients/__init__.py
+++ b/automation/clients/__init__.py
diff --git a/v14/automation/clients/android.py b/automation/clients/android.py
index 069fcafb..069fcafb 100755
--- a/v14/automation/clients/android.py
+++ b/automation/clients/android.py
diff --git a/v14/automation/clients/chromeos.py b/automation/clients/chromeos.py
index ec80a0eb..ec80a0eb 100755
--- a/v14/automation/clients/chromeos.py
+++ b/automation/clients/chromeos.py
diff --git a/v14/automation/clients/crosstool.py b/automation/clients/crosstool.py
index 9844174b..9844174b 100755
--- a/v14/automation/clients/crosstool.py
+++ b/automation/clients/crosstool.py
diff --git a/v14/automation/clients/dejagnu_compiler.py b/automation/clients/dejagnu_compiler.py
index 4bc881e0..4bc881e0 100755
--- a/v14/automation/clients/dejagnu_compiler.py
+++ b/automation/clients/dejagnu_compiler.py
diff --git a/v14/automation/clients/helper/__init__.py b/automation/clients/helper/__init__.py
index 8b137891..8b137891 100644
--- a/v14/automation/clients/helper/__init__.py
+++ b/automation/clients/helper/__init__.py
diff --git a/v14/automation/clients/helper/android.py b/automation/clients/helper/android.py
index f49ccb86..f49ccb86 100644
--- a/v14/automation/clients/helper/android.py
+++ b/automation/clients/helper/android.py
diff --git a/v14/automation/clients/helper/chromeos.py b/automation/clients/helper/chromeos.py
index 4005390e..4005390e 100644
--- a/v14/automation/clients/helper/chromeos.py
+++ b/automation/clients/helper/chromeos.py
diff --git a/v14/automation/clients/helper/crosstool.py b/automation/clients/helper/crosstool.py
index b78e2d86..b78e2d86 100644
--- a/v14/automation/clients/helper/crosstool.py
+++ b/automation/clients/helper/crosstool.py
diff --git a/v14/automation/clients/helper/jobs.py b/automation/clients/helper/jobs.py
index e1827015..e1827015 100644
--- a/v14/automation/clients/helper/jobs.py
+++ b/automation/clients/helper/jobs.py
diff --git a/v14/automation/clients/helper/perforce.py b/automation/clients/helper/perforce.py
index 5e9c261c..5e9c261c 100644
--- a/v14/automation/clients/helper/perforce.py
+++ b/automation/clients/helper/perforce.py
diff --git a/v14/automation/clients/nightly.py b/automation/clients/nightly.py
index bf1ef5a7..bf1ef5a7 100755
--- a/v14/automation/clients/nightly.py
+++ b/automation/clients/nightly.py
diff --git a/v14/automation/clients/output_test.py b/automation/clients/output_test.py
index 7cff8eda..7cff8eda 100755
--- a/v14/automation/clients/output_test.py
+++ b/automation/clients/output_test.py
diff --git a/v14/automation/clients/pwd_test.py b/automation/clients/pwd_test.py
index 2c2118bb..2c2118bb 100755
--- a/v14/automation/clients/pwd_test.py
+++ b/automation/clients/pwd_test.py
diff --git a/v14/automation/clients/report/dejagnu.sh b/automation/clients/report/dejagnu.sh
index fadd8a0c..fadd8a0c 100755
--- a/v14/automation/clients/report/dejagnu.sh
+++ b/automation/clients/report/dejagnu.sh
diff --git a/v14/automation/clients/report/dejagnu/__init__.py b/automation/clients/report/dejagnu/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/clients/report/dejagnu/__init__.py
+++ b/automation/clients/report/dejagnu/__init__.py
diff --git a/v14/automation/clients/report/dejagnu/main.py b/automation/clients/report/dejagnu/main.py
index c05e3e48..c05e3e48 100644
--- a/v14/automation/clients/report/dejagnu/main.py
+++ b/automation/clients/report/dejagnu/main.py
diff --git a/v14/automation/clients/report/dejagnu/manifest.py b/automation/clients/report/dejagnu/manifest.py
index 75d907cd..75d907cd 100644
--- a/v14/automation/clients/report/dejagnu/manifest.py
+++ b/automation/clients/report/dejagnu/manifest.py
diff --git a/v14/automation/clients/report/dejagnu/report.html b/automation/clients/report/dejagnu/report.html
index 39b39e09..39b39e09 100644
--- a/v14/automation/clients/report/dejagnu/report.html
+++ b/automation/clients/report/dejagnu/report.html
diff --git a/v14/automation/clients/report/dejagnu/report.py b/automation/clients/report/dejagnu/report.py
index 7f2375de..7f2375de 100644
--- a/v14/automation/clients/report/dejagnu/report.py
+++ b/automation/clients/report/dejagnu/report.py
diff --git a/v14/automation/clients/report/dejagnu/summary.py b/automation/clients/report/dejagnu/summary.py
index c45fed44..c45fed44 100644
--- a/v14/automation/clients/report/dejagnu/summary.py
+++ b/automation/clients/report/dejagnu/summary.py
diff --git a/v14/automation/clients/report/validate_failures.py b/automation/clients/report/validate_failures.py
index e99c9054..e99c9054 100755
--- a/v14/automation/clients/report/validate_failures.py
+++ b/automation/clients/report/validate_failures.py
diff --git a/v14/automation/common/__init__.py b/automation/common/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/common/__init__.py
+++ b/automation/common/__init__.py
diff --git a/v14/automation/common/command.py b/automation/common/command.py
index 205467cb..205467cb 100644
--- a/v14/automation/common/command.py
+++ b/automation/common/command.py
diff --git a/v14/automation/common/command_executer.py b/automation/common/command_executer.py
index 63e5af71..63e5af71 100644
--- a/v14/automation/common/command_executer.py
+++ b/automation/common/command_executer.py
diff --git a/v14/automation/common/command_executer_test.py b/automation/common/command_executer_test.py
index d3cef898..d3cef898 100755
--- a/v14/automation/common/command_executer_test.py
+++ b/automation/common/command_executer_test.py
diff --git a/v14/automation/common/events.py b/automation/common/events.py
index 79a69422..79a69422 100644
--- a/v14/automation/common/events.py
+++ b/automation/common/events.py
diff --git a/v14/automation/common/job.py b/automation/common/job.py
index 94cd6e2b..94cd6e2b 100644
--- a/v14/automation/common/job.py
+++ b/automation/common/job.py
diff --git a/v14/automation/common/job_group.py b/automation/common/job_group.py
index 6f9466b1..6f9466b1 100644
--- a/v14/automation/common/job_group.py
+++ b/automation/common/job_group.py
diff --git a/v14/automation/common/logger.py b/automation/common/logger.py
index 6bdd0c82..6bdd0c82 100644
--- a/v14/automation/common/logger.py
+++ b/automation/common/logger.py
diff --git a/v14/automation/common/machine.py b/automation/common/machine.py
index aa576c13..aa576c13 100644
--- a/v14/automation/common/machine.py
+++ b/automation/common/machine.py
diff --git a/v14/automation/common/machine_test.py b/automation/common/machine_test.py
index 0d5f32c7..0d5f32c7 100755
--- a/v14/automation/common/machine_test.py
+++ b/automation/common/machine_test.py
diff --git a/v14/automation/common/state_machine.py b/automation/common/state_machine.py
index d97f0fde..d97f0fde 100644
--- a/v14/automation/common/state_machine.py
+++ b/automation/common/state_machine.py
diff --git a/v14/automation/server/__init__.py b/automation/server/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/server/__init__.py
+++ b/automation/server/__init__.py
diff --git a/v14/automation/server/job_executer.py b/automation/server/job_executer.py
index 33080e84..33080e84 100644
--- a/v14/automation/server/job_executer.py
+++ b/automation/server/job_executer.py
diff --git a/v14/automation/server/job_group_manager.py b/automation/server/job_group_manager.py
index 56af1985..56af1985 100644
--- a/v14/automation/server/job_group_manager.py
+++ b/automation/server/job_group_manager.py
diff --git a/v14/automation/server/job_manager.py b/automation/server/job_manager.py
index a858b0de..a858b0de 100644
--- a/v14/automation/server/job_manager.py
+++ b/automation/server/job_manager.py
diff --git a/v14/automation/server/machine_manager.py b/automation/server/machine_manager.py
index 615b22b4..615b22b4 100644
--- a/v14/automation/server/machine_manager.py
+++ b/automation/server/machine_manager.py
diff --git a/v14/automation/server/machine_manager_test.py b/automation/server/machine_manager_test.py
index d84607b1..d84607b1 100755
--- a/v14/automation/server/machine_manager_test.py
+++ b/automation/server/machine_manager_test.py
diff --git a/v14/automation/server/monitor/__init__.py b/automation/server/monitor/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/automation/server/monitor/__init__.py
+++ b/automation/server/monitor/__init__.py
diff --git a/v14/automation/server/monitor/dashboard.py b/automation/server/monitor/dashboard.py
index 236b9cbc..236b9cbc 100644
--- a/v14/automation/server/monitor/dashboard.py
+++ b/automation/server/monitor/dashboard.py
diff --git a/v14/automation/server/monitor/manage.py b/automation/server/monitor/manage.py
index 047c90ee..047c90ee 100755
--- a/v14/automation/server/monitor/manage.py
+++ b/automation/server/monitor/manage.py
diff --git a/v14/automation/server/monitor/settings.py b/automation/server/monitor/settings.py
index e6b7e633..e6b7e633 100644
--- a/v14/automation/server/monitor/settings.py
+++ b/automation/server/monitor/settings.py
diff --git a/v14/automation/server/monitor/start.sh b/automation/server/monitor/start.sh
index 4fc53bef..4fc53bef 100755
--- a/v14/automation/server/monitor/start.sh
+++ b/automation/server/monitor/start.sh
diff --git a/v14/automation/server/monitor/static/style.css b/automation/server/monitor/static/style.css
index b571b059..b571b059 100644
--- a/v14/automation/server/monitor/static/style.css
+++ b/automation/server/monitor/static/style.css
diff --git a/v14/automation/server/monitor/templates/base.html b/automation/server/monitor/templates/base.html
index 95ffc222..95ffc222 100644
--- a/v14/automation/server/monitor/templates/base.html
+++ b/automation/server/monitor/templates/base.html
diff --git a/v14/automation/server/monitor/templates/job.html b/automation/server/monitor/templates/job.html
index 90acd969..90acd969 100644
--- a/v14/automation/server/monitor/templates/job.html
+++ b/automation/server/monitor/templates/job.html
diff --git a/v14/automation/server/monitor/templates/job_group.html b/automation/server/monitor/templates/job_group.html
index b6ed8ea8..b6ed8ea8 100644
--- a/v14/automation/server/monitor/templates/job_group.html
+++ b/automation/server/monitor/templates/job_group.html
diff --git a/v14/automation/server/monitor/templates/job_group_list.html b/automation/server/monitor/templates/job_group_list.html
index b82fa730..b82fa730 100644
--- a/v14/automation/server/monitor/templates/job_group_list.html
+++ b/automation/server/monitor/templates/job_group_list.html
diff --git a/v14/automation/server/monitor/templates/job_log.html b/automation/server/monitor/templates/job_log.html
index 937b21b0..937b21b0 100644
--- a/v14/automation/server/monitor/templates/job_log.html
+++ b/automation/server/monitor/templates/job_log.html
diff --git a/v14/automation/server/monitor/templates/machine_list.html b/automation/server/monitor/templates/machine_list.html
index f81422d3..f81422d3 100644
--- a/v14/automation/server/monitor/templates/machine_list.html
+++ b/automation/server/monitor/templates/machine_list.html
diff --git a/v14/automation/server/monitor/templates/snippet_attribute_table.html b/automation/server/monitor/templates/snippet_attribute_table.html
index 24bacc17..24bacc17 100644
--- a/v14/automation/server/monitor/templates/snippet_attribute_table.html
+++ b/automation/server/monitor/templates/snippet_attribute_table.html
diff --git a/v14/automation/server/monitor/templates/snippet_code.html b/automation/server/monitor/templates/snippet_code.html
index 281754d6..281754d6 100644
--- a/v14/automation/server/monitor/templates/snippet_code.html
+++ b/automation/server/monitor/templates/snippet_code.html
diff --git a/v14/automation/server/monitor/templates/snippet_links.html b/automation/server/monitor/templates/snippet_links.html
index f19fa6e5..f19fa6e5 100644
--- a/v14/automation/server/monitor/templates/snippet_links.html
+++ b/automation/server/monitor/templates/snippet_links.html
diff --git a/v14/automation/server/monitor/urls.py b/automation/server/monitor/urls.py
index 80aa7d2a..80aa7d2a 100644
--- a/v14/automation/server/monitor/urls.py
+++ b/automation/server/monitor/urls.py
diff --git a/v14/automation/server/server.py b/automation/server/server.py
index ae761893..ae761893 100755
--- a/v14/automation/server/server.py
+++ b/automation/server/server.py
diff --git a/v14/automation/server/server_test.py b/automation/server/server_test.py
index 40cf491f..40cf491f 100755
--- a/v14/automation/server/server_test.py
+++ b/automation/server/server_test.py
diff --git a/v14/automation/server/test_pool.csv b/automation/server/test_pool.csv
index b0700c9b..b0700c9b 100644
--- a/v14/automation/server/test_pool.csv
+++ b/automation/server/test_pool.csv
diff --git a/v14/build-binutils/opts.sh b/build-binutils/opts.sh
index e69de29b..e69de29b 100644
--- a/v14/build-binutils/opts.sh
+++ b/build-binutils/opts.sh
diff --git a/v14/build-gcc/opts.sh b/build-gcc/opts.sh
index d1e6fadb..d1e6fadb 100644
--- a/v14/build-gcc/opts.sh
+++ b/build-gcc/opts.sh
diff --git a/v14/build_benchmarks.py b/build_benchmarks.py
index 41079f80..41079f80 100755
--- a/v14/build_benchmarks.py
+++ b/build_benchmarks.py
diff --git a/v14/build_chrome_browser.py b/build_chrome_browser.py
index f162c1d4..f162c1d4 100755
--- a/v14/build_chrome_browser.py
+++ b/build_chrome_browser.py
diff --git a/v14/build_chromeos.py b/build_chromeos.py
index 483e44a8..483e44a8 100755
--- a/v14/build_chromeos.py
+++ b/build_chromeos.py
diff --git a/v14/build_tc.py b/build_tc.py
index 0c009b3a..0c009b3a 100755
--- a/v14/build_tc.py
+++ b/build_tc.py
diff --git a/v14/command_executer_timeout_test.py b/command_executer_timeout_test.py
index 446651d3..446651d3 100755
--- a/v14/command_executer_timeout_test.py
+++ b/command_executer_timeout_test.py
diff --git a/v14/compare_benchmarks.py b/compare_benchmarks.py
index e63dfea7..e63dfea7 100755
--- a/v14/compare_benchmarks.py
+++ b/compare_benchmarks.py
diff --git a/v14/crb/autotest_gatherer.py b/crb/autotest_gatherer.py
index da39040d..da39040d 100644
--- a/v14/crb/autotest_gatherer.py
+++ b/crb/autotest_gatherer.py
diff --git a/v14/crb/autotest_run.py b/crb/autotest_run.py
index d6dc70f5..d6dc70f5 100644
--- a/v14/crb/autotest_run.py
+++ b/crb/autotest_run.py
diff --git a/v14/crb/crb_driver.py b/crb/crb_driver.py
index 6cf7af35..6cf7af35 100755
--- a/v14/crb/crb_driver.py
+++ b/crb/crb_driver.py
diff --git a/v14/crb/machine_manager_singleton.py b/crb/machine_manager_singleton.py
index 93629c4c..93629c4c 100644
--- a/v14/crb/machine_manager_singleton.py
+++ b/crb/machine_manager_singleton.py
diff --git a/v14/crb/table_formatter.py b/crb/table_formatter.py
index b3b82f09..b3b82f09 100644
--- a/v14/crb/table_formatter.py
+++ b/crb/table_formatter.py
diff --git a/v14/cros_login.py b/cros_login.py
index 44b22643..44b22643 100755
--- a/v14/cros_login.py
+++ b/cros_login.py
diff --git a/crosperf/benchmark.py b/crosperf/benchmark.py
index bc7f1fa8..8fe8a492 100644
--- a/crosperf/benchmark.py
+++ b/crosperf/benchmark.py
@@ -14,11 +14,13 @@ class Benchmark(object):
   """
 
   def __init__(self, name, autotest_name, autotest_args, iterations,
-               outlier_range, perf_args):
+               outlier_range, key_results_only, rm_chroot_tmp, perf_args):
     self.name = name
     self.autotest_name = autotest_name
     self.autotest_args = autotest_args
     self.iterations = iterations
     self.outlier_range = outlier_range
     self.perf_args = perf_args
+    self.key_results_only = key_results_only
+    self.rm_chroot_tmp = rm_chroot_tmp
     self.iteration_adjusted = False
diff --git a/crosperf/benchmark_run.py b/crosperf/benchmark_run.py
index dc837937..80c95c4d 100644
--- a/crosperf/benchmark_run.py
+++ b/crosperf/benchmark_run.py
@@ -29,7 +29,8 @@ class BenchmarkRun(threading.Thread):
                iteration,
                cache_conditions,
                machine_manager,
-               logger_to_use):
+               logger_to_use,
+               share_users):
     threading.Thread.__init__(self)
     self.name = name
     self._logger = logger_to_use
@@ -53,6 +54,7 @@ class BenchmarkRun(threading.Thread):
     self._ce = command_executer.GetCommandExecuter(self._logger)
     self.timeline = timeline.Timeline()
     self.timeline.Record(STATUS_PENDING)
+    self.share_users = share_users
 
   def run(self):
     try:
@@ -67,7 +69,8 @@ class BenchmarkRun(threading.Thread):
                       self.label.board,
                       self.cache_conditions,
                       self._logger,
-                      self.label
+                      self.label,
+                      self.share_users
                      )
 
       self.result = self.cache.ReadResult()
diff --git a/crosperf/benchmark_run_unittest.py b/crosperf/benchmark_run_unittest.py
index c4670c9c..47e027f4 100755
--- a/crosperf/benchmark_run_unittest.py
+++ b/crosperf/benchmark_run_unittest.py
@@ -19,14 +19,19 @@ from results_cache import MockResultsCache
 class BenchmarkRunTest(unittest.TestCase):
   def testDryRun(self):
     my_label = MockLabel("test1", "image1", "/tmp/test_benchmark_run",
-                         "x86-alex", "chromeos-alex1", "")
-    m = MockMachineManager("/tmp/chromeos_root")
+                         "x86-alex", "chromeos-alex1",
+                         image_args="",
+                         image_md5sum="",
+                         cache_dir="")
+    m = MockMachineManager("/tmp/chromeos_root", 0)
     m.AddMachine("chromeos-alex1")
     bench = Benchmark("PageCyler",
                       "Pyautoperf",
                       "",
                       1,
                       0.2,
+                      False,
+                      False,
                       "")
     b = MockBenchmarkRun("test run",
                          bench,
@@ -34,7 +39,8 @@ class BenchmarkRunTest(unittest.TestCase):
                          1,
                          [],
                          m,
-                         logger.GetLogger())
+                         logger.GetLogger(),
+                         "")
     b.cache = MockResultsCache()
     b.autotest_runner = MockAutotestRunner()
     b.start()
diff --git a/v14/crosperf/config.py b/crosperf/config.py
index 45a3d000..45a3d000 100644
--- a/v14/crosperf/config.py
+++ b/crosperf/config.py
diff --git a/crosperf/crosperf.py b/crosperf/crosperf.py
index cfb48d7c..cb7911fd 100755
--- a/crosperf/crosperf.py
+++ b/crosperf/crosperf.py
@@ -18,8 +18,6 @@ from utils import logger
 
 import test_flag
 
-l = logger.GetLogger()
-
 
 class MyIndentedHelpFormatter(optparse.IndentedHelpFormatter):
   def format_description(self, description):
@@ -65,12 +63,20 @@ def Main(argv):
                                  description=Help().GetHelp(),
                                  formatter=MyIndentedHelpFormatter(),
                                  version="%prog 0.1")
+
+  parser.add_option("-l", "--log_dir",
+                    dest="log_dir",
+                    default="",
+                    help="The log_dir, default is under <crosperf_logs>/logs")
+
   SetupParserOptions(parser)
   options, args = parser.parse_args(argv)
 
   # Convert the relevant options that are passed in into a settings
   # object which will override settings in the experiment file.
   option_settings = ConvertOptionsToSettings(options)
+  log_dir = os.path.abspath(os.path.expanduser(options.log_dir))
+  logger.GetLogger(log_dir)
 
   if len(args) == 2:
     experiment_filename = args[1]
@@ -87,7 +93,8 @@ def Main(argv):
     experiment_name = os.path.basename(experiment_filename)
     experiment_file.GetGlobalSettings().SetField("name", experiment_name)
   experiment = ExperimentFactory().GetExperiment(experiment_file,
-                                                 working_directory)
+                                                 working_directory,
+                                                 log_dir)
 
   atexit.register(Cleanup, experiment)
 
diff --git a/crosperf/experiment.py b/crosperf/experiment.py
index e9dc3d07..2a4590c4 100644
--- a/crosperf/experiment.py
+++ b/crosperf/experiment.py
@@ -9,23 +9,20 @@ import time
 
 from utils import logger
 
-from autotest_runner import AutotestRunner
 from benchmark_run import BenchmarkRun
 from machine_manager import MachineManager
 from machine_manager import MockMachineManager
-from results_cache import ResultsCache
-from results_report import HTMLResultsReport
 import test_flag
 
 
 class Experiment(object):
   """Class representing an Experiment to be run."""
 
-  def __init__(self, name, remote, rerun_if_failed, working_directory,
+  def __init__(self, name, remote, working_directory,
                chromeos_root, cache_conditions, labels, benchmarks,
-               experiment_file, email_to):
+               experiment_file, email_to, acquire_timeout, log_dir,
+               share_users):
     self.name = name
-    self.rerun_if_failed = rerun_if_failed
     self.working_directory = working_directory
     self.remote = remote
     self.chromeos_root = chromeos_root
@@ -34,11 +31,12 @@ class Experiment(object):
     self.email_to = email_to
     self.results_directory = os.path.join(self.working_directory,
                                           self.name + "_results")
-
+    self.log_dir = log_dir
     self.labels = labels
     self.benchmarks = benchmarks
     self.num_complete = 0
     self.num_run_complete = 0
+    self.share_users = share_users
 
     # We need one chromeos_root to run the benchmarks in, but it doesn't
     # matter where it is, unless the ABIs are different.
@@ -51,10 +49,10 @@ class Experiment(object):
                       "the image path.")
 
     if test_flag.GetTestMode():
-      self.machine_manager = MockMachineManager(chromeos_root)
+      self.machine_manager = MockMachineManager(chromeos_root, acquire_timeout)
     else:
-      self.machine_manager = MachineManager(chromeos_root)
-    self.l = logger.GetLogger()
+      self.machine_manager = MachineManager(chromeos_root, acquire_timeout)
+    self.l = logger.GetLogger(log_dir)
 
     for machine in remote:
       self.machine_manager.AddMachine(machine)
@@ -75,7 +73,7 @@ class Experiment(object):
           benchmark_run_name = "%s: %s (%s)" % (label.name, benchmark.name,
                                                 iteration)
           full_name = "%s_%s_%s" % (label.name, benchmark.name, iteration)
-          logger_to_use = logger.Logger(os.path.dirname(__file__),
+          logger_to_use = logger.Logger(self.log_dir,
                                         "run.%s" % (full_name),
                                         True)
           benchmark_run = BenchmarkRun(benchmark_run_name,
@@ -84,7 +82,8 @@ class Experiment(object):
                                        iteration,
                                        self.cache_conditions,
                                        self.machine_manager,
-                                       logger_to_use)
+                                       logger_to_use,
+                                       self.share_users)
 
           benchmark_runs.append(benchmark_run)
     return benchmark_runs
diff --git a/crosperf/experiment_factory.py b/crosperf/experiment_factory.py
index bd3076dd..3c92ee3e 100644
--- a/crosperf/experiment_factory.py
+++ b/crosperf/experiment_factory.py
@@ -7,6 +7,7 @@ import os
 import socket
 
 from benchmark import Benchmark
+import config
 from experiment import Experiment
 from label import Label
 from label import MockLabel
@@ -22,13 +23,18 @@ class ExperimentFactory(object):
   of experiments could be produced.
   """
 
-  def GetExperiment(self, experiment_file, working_directory):
+  def GetExperiment(self, experiment_file, working_directory, log_dir):
     """Construct an experiment from an experiment file."""
     global_settings = experiment_file.GetGlobalSettings()
     experiment_name = global_settings.GetField("name")
     remote = global_settings.GetField("remote")
-    rerun_if_failed = global_settings.GetField("rerun_if_failed")
     chromeos_root = global_settings.GetField("chromeos_root")
+    rm_chroot_tmp = global_settings.GetField("rm_chroot_tmp")
+    key_results_only = global_settings.GetField("key_results_only")
+    acquire_timeout= global_settings.GetField("acquire_timeout")
+    cache_dir = global_settings.GetField("cache_dir")
+    config.AddConfig("no_email", global_settings.GetField("no_email"))
+    share_users = global_settings.GetField("share_users")
 
     # Default cache hit conditions. The image checksum in the cache and the
     # computed checksum of the image must match. Also a cache file must exist.
@@ -55,8 +61,13 @@ class ExperimentFactory(object):
       iterations = benchmark_settings.GetField("iterations")
       outlier_range = benchmark_settings.GetField("outlier_range")
       perf_args = benchmark_settings.GetField("perf_args")
+      rm_chroot_tmp = benchmark_settings.GetField("rm_chroot_tmp")
+      key_results_only = benchmark_settings.GetField("key_results_only")
+
       benchmark = Benchmark(benchmark_name, autotest_name, autotest_args,
-                            iterations, outlier_range, perf_args)
+                            iterations, outlier_range,
+                            key_results_only, rm_chroot_tmp,
+                            perf_args)
       benchmarks.append(benchmark)
 
     # Construct labels.
@@ -69,6 +80,8 @@ class ExperimentFactory(object):
       chromeos_root = label_settings.GetField("chromeos_root")
       board = label_settings.GetField("board")
       my_remote = label_settings.GetField("remote")
+      image_md5sum = label_settings.GetField("md5sum")
+      cache_dir = label_settings.GetField("cache_dir")
     # TODO(yunlian): We should consolidate code in machine_manager.py
     # to derermine whether we are running from within google or not
       if ("corp.google.com" in socket.gethostname() and
@@ -83,19 +96,19 @@ class ExperimentFactory(object):
       image_args = label_settings.GetField("image_args")
       if test_flag.GetTestMode():
         label = MockLabel(label_name, image, chromeos_root, board, my_remote,
-                          image_args)
+                          image_args, image_md5sum, cache_dir)
       else:
         label = Label(label_name, image, chromeos_root, board, my_remote,
-                      image_args)
+                      image_args, image_md5sum, cache_dir)
       labels.append(label)
 
     email = global_settings.GetField("email")
     all_remote = list(set(all_remote))
-    experiment = Experiment(experiment_name, all_remote, rerun_if_failed,
+    experiment = Experiment(experiment_name, all_remote,
                             working_directory, chromeos_root,
                             cache_conditions, labels, benchmarks,
                             experiment_file.Canonicalize(),
-                            email)
+                            email, acquire_timeout, log_dir, share_users)
 
     return experiment
 
diff --git a/crosperf/experiment_factory_unittest.py b/crosperf/experiment_factory_unittest.py
index fa943519..6cee6b74 100755
--- a/crosperf/experiment_factory_unittest.py
+++ b/crosperf/experiment_factory_unittest.py
@@ -32,7 +32,9 @@ EXPERIMENT_FILE_1 = """
 class ExperimentFactoryTest(unittest.TestCase):
   def testLoadExperimentFile1(self):
     experiment_file = ExperimentFile(StringIO.StringIO(EXPERIMENT_FILE_1))
-    experiment = ExperimentFactory().GetExperiment(experiment_file, "")
+    experiment = ExperimentFactory().GetExperiment(experiment_file, 
+                                                   working_directory="",
+                                                   log_dir="")
     self.assertEqual(experiment.remote, ["chromeos-alex3"])
 
     self.assertEqual(len(experiment.benchmarks), 1)
diff --git a/crosperf/experiment_runner.py b/crosperf/experiment_runner.py
index b905bbdc..9212ba56 100644
--- a/crosperf/experiment_runner.py
+++ b/crosperf/experiment_runner.py
@@ -12,6 +12,7 @@ from utils import logger
 from utils.email_sender import EmailSender
 from utils.file_utils import FileUtils
 
+import config
 from experiment_status import ExperimentStatus
 from results_report import HTMLResultsReport
 from results_report import TextResultsReport
@@ -25,7 +26,7 @@ class ExperimentRunner(object):
 
   def __init__(self, experiment):
     self._experiment = experiment
-    self.l = logger.GetLogger()
+    self.l = logger.GetLogger(experiment.log_dir)
     self._ce = command_executer.GetCommandExecuter(self.l)
     self._terminated = False
 
@@ -58,7 +59,8 @@ class ExperimentRunner(object):
       if not benchmark_run.cache_hit:
         send_mail = True
         break
-    if not send_mail and not experiment.email_to:
+    if (not send_mail and not experiment.email_to
+        or config.GetConfig("no_email")):
       return
 
     label_names = []
@@ -100,7 +102,7 @@ class ExperimentRunner(object):
         benchmark_run_path = os.path.join(results_directory,
                                           benchmark_run_name)
         benchmark_run.result.CopyResultsTo(benchmark_run_path)
-        benchmark_run.result.CleanUp()
+        benchmark_run.result.CleanUp(benchmark_run.benchmark.rm_chroot_tmp)
 
   def Run(self):
     self._Run(self._experiment)
diff --git a/crosperf/image_checksummer.py b/crosperf/image_checksummer.py
index f75dc944..dcc1cb02 100644
--- a/crosperf/image_checksummer.py
+++ b/crosperf/image_checksummer.py
@@ -2,24 +2,38 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+import os
 import threading
+
 from utils import logger
 from utils.file_utils import FileUtils
 
 
 class ImageChecksummer(object):
   class PerImageChecksummer(object):
-    def __init__(self, filename):
+    def __init__(self, label):
       self._lock = threading.Lock()
-      self.filename = filename
+      self.label = label
       self._checksum = None
 
     def Checksum(self):
       with self._lock:
         if not self._checksum:
-          logger.GetLogger().LogOutput("Computing checksum for '%s'." %
-                                       self.filename)
-          self._checksum = FileUtils().Md5File(self.filename)
+          logger.GetLogger().LogOutput("Acquiring checksum for '%s'." %
+                                       self.label.name)
+          self._checksum = None
+          if self.label.chromeos_image:
+            if os.path.exists(self.label.chromeos_image):
+              self._checksum = FileUtils().Md5File(self.label.chromeos_image)
+              logger.GetLogger().LogOutput("Computed checksum is "
+                                           ": %s" % self._checksum)
+          if not self._checksum:
+            if self.label.image_md5sum:
+              self._checksum = self.label.image_md5sum
+              logger.GetLogger().LogOutput("Checksum in experiment file is "
+                                           ": %s" % self._checksum)
+            else:
+              raise Exception("Checksum computing error.")
           logger.GetLogger().LogOutput("Checksum is: %s" % self._checksum)
         return self._checksum
 
@@ -34,16 +48,16 @@ class ImageChecksummer(object):
                                                              *args, **kwargs)
       return cls._instance
 
-  def Checksum(self, filename):
+  def Checksum(self, label):
     with self._lock:
-      if filename not in self._per_image_checksummers:
-        self._per_image_checksummers[filename] = (ImageChecksummer.
-                                                  PerImageChecksummer(filename))
-      checksummer = self._per_image_checksummers[filename]
+      if label.name not in self._per_image_checksummers:
+        self._per_image_checksummers[label.name] = (ImageChecksummer.
+                                                    PerImageChecksummer(label))
+      checksummer = self._per_image_checksummers[label.name]
 
     try:
       return checksummer.Checksum()
     except Exception, e:
-      logger.GetLogger().LogError("Could not compute checksum of file '%s'."
-                                  % filename)
+      logger.GetLogger().LogError("Could not compute checksum of image in label"
+                                  " '%s'."% label.name)
       raise e
diff --git a/crosperf/label.py b/crosperf/label.py
index 64ce352f..be7a868e 100644
--- a/crosperf/label.py
+++ b/crosperf/label.py
@@ -10,7 +10,7 @@ from utils.file_utils import FileUtils
 
 class Label(object):
   def __init__(self, name, chromeos_image, chromeos_root, board, remote,
-               image_args):
+               image_args, image_md5sum, cache_dir):
     # Expand ~
     chromeos_root = os.path.expanduser(chromeos_root)
     chromeos_image = os.path.expanduser(chromeos_image)
@@ -20,6 +20,8 @@ class Label(object):
     self.board = board
     self.remote = remote
     self.image_args = image_args
+    self.image_md5sum = image_md5sum
+    self.cache_dir = cache_dir
 
     if not chromeos_root:
       chromeos_root = FileUtils().ChromeOSRootFromImage(chromeos_image)
@@ -38,13 +40,15 @@ class Label(object):
 
 class MockLabel(object):
   def __init__(self, name, chromeos_image, chromeos_root, board, remote,
-               image_args):
+               image_args, image_md5sum, cache_dir):
     self.name = name
     self.chromeos_image = chromeos_image
     self.board = board
     self.remote = remote
+    self.cache_dir = cache_dir
     if not chromeos_root:
       self.chromeos_root = "/tmp/chromeos_root"
     else:
       self.chromeos_root = chromeos_root
     self.image_args = image_args
+    self.image_md5sum = image_md5sum
diff --git a/crosperf/machine_manager.py b/crosperf/machine_manager.py
index 9eb9bcdf..29a4df7a 100644
--- a/crosperf/machine_manager.py
+++ b/crosperf/machine_manager.py
@@ -111,12 +111,12 @@ class CrosMachine(object):
 
   def _GetMachineID(self):
     ce = command_executer.GetCommandExecuter()
-    command = "ifconfig"
+    command = "dump_vpd_log --full --stdout"
     ret, if_out, _ = ce.CrosRunCommand(
         command, return_output=True,
         machine=self.name, chromeos_root=self.chromeos_root)
     b = if_out.splitlines()
-    a = [l for l in b if "lan" in l]
+    a = [l for l in b if "Product" in l]
     self.machine_id = a[0]
     assert ret == 0, "Could not get machine_id from machine: %s" % self.name
 
@@ -131,7 +131,7 @@ class CrosMachine(object):
 
 
 class MachineManager(object):
-  def __init__(self, chromeos_root):
+  def __init__(self, chromeos_root, acquire_timeout):
     self._lock = threading.RLock()
     self._all_machines = []
     self._machines = []
@@ -140,6 +140,7 @@ class MachineManager(object):
     self.chromeos_root = None
     self.machine_checksum = {}
     self.machine_checksum_string = {}
+    self.acquire_timeout = acquire_timeout
 
     if os.path.isdir(lock_machine.Machine.LOCKS_DIR):
       self.no_lock = False
@@ -149,7 +150,7 @@ class MachineManager(object):
     self.chromeos_root = chromeos_root
 
   def ImageMachine(self, machine, label):
-    checksum = ImageChecksummer().Checksum(label.chromeos_image)
+    checksum = ImageChecksummer().Checksum(label)
     if machine.checksum == checksum:
       return
     chromeos_root = label.chromeos_root
@@ -193,8 +194,8 @@ class MachineManager(object):
     with self._lock:
       assert cros_machine, "Machine can't be None"
       for m in self._machines:
-        assert m.name != cros_machine.name, (
-            "Tried to double-lock %s" % cros_machine.name)
+        if m.name == cros_machine.name:
+          return
       if self.no_lock:
         locked = True
       else:
@@ -226,25 +227,33 @@ class MachineManager(object):
     return len(set(checksums)) == 1
 
   def AcquireMachine(self, chromeos_image, label):
-    image_checksum = ImageChecksummer().Checksum(chromeos_image)
+    image_checksum = ImageChecksummer().Checksum(label)
     machines = self.GetMachines(label)
+    check_interval_time = 120
     with self._lock:
       # Lazily external lock machines
-
-      for m in machines:
-        if m not in self._initialized_machines:
-          self._initialized_machines.append(m)
+      while self.acquire_timeout >= 0:
+        for m in machines:
+          new_machine = m not in self._all_machines
           self._TryToLockMachine(m)
-          m.released_time = time.time()
-      if not self.AreAllMachineSame(label):
-        logger.GetLogger().LogFatal("-- not all the machine are identical")
-      if not self.GetAvailableMachines(label):
+          if new_machine:
+            m.released_time = time.time()
+        if not self.AreAllMachineSame(label):
+          logger.GetLogger().LogFatal("-- not all the machine are identical")
+        if self.GetAvailableMachines(label):
+          break
+        else:
+          sleep_time = max(1, min(self.acquire_timeout, check_interval_time))
+          time.sleep(sleep_time)
+          self.acquire_timeout -= sleep_time
+
+      if self.acquire_timeout < 0:
         machine_names = []
         for machine in machines:
           machine_names.append(machine.name)
         logger.GetLogger().LogFatal("Could not acquire any of the "
-                                  "following machines: '%s'"
-                                  % ", ".join(machine_names))
+                                    "following machines: '%s'"
+                                    % ", ".join(machine_names))
 
 ###      for m in self._machines:
 ###        if (m.locked and time.time() - m.released_time < 10 and
@@ -374,8 +383,8 @@ class MockCrosMachine(CrosMachine):
 
 class MockMachineManager(MachineManager):
 
-  def __init__(self, chromeos_root):
-    super(MockMachineManager, self).__init__(chromeos_root)
+  def __init__(self, chromeos_root, acquire_timeout):
+    super(MockMachineManager, self).__init__(chromeos_root, acquire_timeout)
 
   def _TryToLockMachine(self, cros_machine):
     self._machines.append(cros_machine)
diff --git a/crosperf/machine_manager_unittest.py b/crosperf/machine_manager_unittest.py
index 98baf456..84266d5e 100755
--- a/crosperf/machine_manager_unittest.py
+++ b/crosperf/machine_manager_unittest.py
@@ -12,7 +12,7 @@ import machine_manager
 class MyMachineManager(machine_manager.MachineManager):
 
   def __init__(self, chromeos_root):
-    super(MyMachineManager, self).__init__(chromeos_root)
+    super(MyMachineManager, self).__init__(chromeos_root, 0)
 
   def _TryToLockMachine(self, cros_machine):
     self._machines.append(cros_machine)
@@ -30,9 +30,11 @@ class MyMachineManager(machine_manager.MachineManager):
 CHROMEOS_ROOT = "/tmp/chromeos-root"
 MACHINE_NAMES = ["lumpy1", "lumpy2", "lumpy3", "daisy1", "daisy2"]
 LABEL_LUMPY = label.MockLabel("lumpy", "image", CHROMEOS_ROOT, "lumpy",
-                              ["lumpy1", "lumpy2", "lumpy3", "lumpy4"], "")
+                              ["lumpy1", "lumpy2", "lumpy3", "lumpy4"],
+                              "", "", "")
 LABEL_MIX = label.MockLabel("mix", "image", CHROMEOS_ROOT, "mix",
-                            ["daisy1", "daisy2", "lumpy3", "lumpy4"], "")
+                            ["daisy1", "daisy2", "lumpy3", "lumpy4"],
+                            "", "", "")
 
 
 class MachineManagerTest(unittest.TestCase):
diff --git a/crosperf/perf_table.py b/crosperf/perf_table.py
index b3387ea8..3c8b88b8 100644
--- a/crosperf/perf_table.py
+++ b/crosperf/perf_table.py
@@ -7,6 +7,7 @@ import os
 
 from utils import perf_diff
 
+
 def ParsePerfReport(perf_file):
   """It should return a dict."""
 
@@ -22,9 +23,16 @@ class PerfTable(object):
     self._label_names = label_names
     self.perf_data = {}
     self.GenerateData()
-    # {benchmark:{perf_event1:[[{func1:number, func2:number},
-    #                           {func1: number, func2: number}]], ...},
+
+    # {benchmark:{perf_event1:[[{func1:number, func2:number,
+    #                             rows_to_show: number}
+    #                           {func1: number, func2: number
+    #                             rows_to_show: number}]], ...},
     #  benchmark2:...}
+    # The rows_to_show is temp data recording how many
+    # rows have over 1% running time.
+    self.row_info = {}
+    self.GetRowsToShow()
 
   def GenerateData(self):
     for label in self._label_names:
@@ -39,9 +47,10 @@ class PerfTable(object):
 
   def ReadPerfReport(self, perf_file, label, benchmark_name, iteration):
     """Add the data from one run to the dict."""
-    if not os.path.isfile(perf_file):
-      return
-    perf_of_run = perf_diff.GetPerfDictFromReport(perf_file)
+    if os.path.isfile(perf_file):
+      perf_of_run = perf_diff.GetPerfDictFromReport(perf_file)
+    else:
+      perf_of_run = {}
     if benchmark_name not in self.perf_data:
       self.perf_data[benchmark_name] = {}
       for event in perf_of_run:
@@ -55,4 +64,22 @@ class PerfTable(object):
       data_for_label = ben_data[event][label_index]
       while len(data_for_label) <= iteration:
         data_for_label.append({})
-      data_for_label[iteration] = perf_of_run[event]
+      if perf_of_run:
+        data_for_label[iteration] = perf_of_run[event]
+      else:
+        data_for_label[iteration] = {}
+
+  def GetRowsToShow(self):
+    for benchmark in self.perf_data:
+      if benchmark not in self.row_info:
+        self.row_info[benchmark] = {}
+      for event in self.perf_data[benchmark]:
+        rows = 0
+        for run in self.perf_data[benchmark][event]:
+          for iteration in run:
+            if perf_diff.ROWS_TO_SHOW in iteration:
+              rows = max(iteration[perf_diff.ROWS_TO_SHOW], rows)
+              # delete the temp data which stores how many rows of
+              # the perf data have over 1% running time.
+              del iteration[perf_diff.ROWS_TO_SHOW]
+        self.row_info[benchmark][event] = rows
diff --git a/crosperf/results_cache.py b/crosperf/results_cache.py
index c0600962..0357275d 100644
--- a/crosperf/results_cache.py
+++ b/crosperf/results_cache.py
@@ -15,7 +15,8 @@ from utils import misc
 
 from image_checksummer import ImageChecksummer
 
-SCRATCH_DIR = "/home/%s/cros_scratch" % getpass.getuser()
+SCRATCH_BASE = "/home/%s/cros_scratch"
+SCRATCH_DIR = SCRATCH_BASE % getpass.getuser()
 RESULTS_FILE = "results.txt"
 MACHINE_FILE = "machine.txt"
 AUTOTEST_TARBALL = "autotest.tbz2"
@@ -55,16 +56,18 @@ class Result(object):
     self._CopyFilesTo(dest_dir, self.perf_report_files)
 
   def _GetKeyvals(self):
-    generate_test_report = os.path.join(self._chromeos_root,
-                                        "src",
-                                        "platform",
-                                        "crostestutils",
-                                        "utils_py",
-                                        "generate_test_report.py")
-    command = ("python %s --no-color --csv %s" %
-               (generate_test_report,
-                self.results_dir))
-    [_, out, _] = self._ce.RunCommand(command, return_output=True)
+    results_in_chroot = os.path.join(self._chromeos_root,
+                                     "chroot", "tmp")
+    if not self._temp_dir:
+      self._temp_dir = tempfile.mkdtemp(dir=results_in_chroot)
+      command = "cp -r {0}/* {1}".format(self.results_dir, self._temp_dir)
+      self._ce.RunCommand(command)
+
+    command = ("python generate_test_report --no-color --csv %s" %
+               (os.path.join("/tmp", os.path.basename(self._temp_dir))))
+    [_, out, _] = self._ce.ChrootRunCommand(self._chromeos_root,
+                                            command,
+                                            return_output=True)
     keyvals_dict = {}
     for line in out.splitlines():
       tokens = re.split("=|,", line)
@@ -177,7 +180,9 @@ class Result(object):
       self.retval = pickle.load(f)
 
     # Untar the tarball to a temporary directory
-    self._temp_dir = tempfile.mkdtemp()
+    self._temp_dir = tempfile.mkdtemp(dir=os.path.join(self._chromeos_root,
+                                                       "chroot", "tmp"))
+
     command = ("cd %s && tar xf %s" %
                (self._temp_dir,
                 os.path.join(cache_dir, AUTOTEST_TARBALL)))
@@ -189,24 +194,25 @@ class Result(object):
     self.perf_report_files = self._GetPerfReportFiles()
     self._ProcessResults()
 
-  def CleanUp(self):
+  def CleanUp(self, rm_chroot_tmp):
+    if rm_chroot_tmp:
+      command = "rm -rf %s" % self.results_dir
+      self._ce.RunCommand(command)
     if self._temp_dir:
       command = "rm -rf %s" % self._temp_dir
       self._ce.RunCommand(command)
 
   def StoreToCacheDir(self, cache_dir, machine_manager):
     # Create the dir if it doesn't exist.
-    command = "mkdir -p %s" % cache_dir
-    ret = self._ce.RunCommand(command)
-    if ret:
-      raise Exception("Could not create cache dir: %s" % cache_dir)
-    # Store to the cache directory.
-    with open(os.path.join(cache_dir, RESULTS_FILE), "w") as f:
+    temp_dir = tempfile.mkdtemp()
+
+    # Store to the temp directory.
+    with open(os.path.join(temp_dir, RESULTS_FILE), "w") as f:
       pickle.dump(self.out, f)
       pickle.dump(self.err, f)
       pickle.dump(self.retval, f)
 
-    tarball = os.path.join(cache_dir, AUTOTEST_TARBALL)
+    tarball = os.path.join(temp_dir, AUTOTEST_TARBALL)
     command = ("cd %s && "
                "tar "
                "--exclude=var/spool "
@@ -218,9 +224,22 @@ class Result(object):
     # Store machine info.
     # TODO(asharif): Make machine_manager a singleton, and don't pass it into
     # this function.
-    with open(os.path.join(cache_dir, MACHINE_FILE), "w") as f:
+    with open(os.path.join(temp_dir, MACHINE_FILE), "w") as f:
       f.write(machine_manager.machine_checksum_string[self.label_name])
 
+    if os.path.exists(cache_dir):
+      command = "rm -rf {0}".format(cache_dir)
+      self._ce.RunCommand(command)
+
+    command = "mkdir -p {0} && ".format(os.path.dirname(cache_dir))
+    command += "mv {0} {1}".format(temp_dir, cache_dir)
+    ret = self._ce.RunCommand(command)
+    if ret:
+      command = "rm -rf {0}".format(temp_dir)
+      self._ce.RunCommand(command)
+      raise Exception("Could not move dir %s to dir %s" %
+                      (temp_dir, cache_dir))
+
   @classmethod
   def CreateFromRun(cls, logger, chromeos_root, board, label_name,
                     out, err, retval):
@@ -273,7 +292,7 @@ class ResultsCache(object):
 
   def Init(self, chromeos_image, chromeos_root, autotest_name, iteration,
            autotest_args, machine_manager, board, cache_conditions,
-           logger_to_use, label):
+           logger_to_use, label, share_users):
     self.chromeos_image = chromeos_image
     self.chromeos_root = chromeos_root
     self.autotest_name = autotest_name
@@ -285,10 +304,12 @@ class ResultsCache(object):
     self._logger = logger_to_use
     self._ce = command_executer.GetCommandExecuter(self._logger)
     self.label = label
+    self.share_users = share_users
 
   def _GetCacheDirForRead(self):
-    glob_path = self._FormCacheDir(self._GetCacheKeyList(True))
-    matching_dirs = glob.glob(glob_path)
+    matching_dirs = []
+    for glob_path in self._FormCacheDir(self._GetCacheKeyList(True)):
+      matching_dirs += glob.glob(glob_path)
 
     if matching_dirs:
       # Cache file found.
@@ -297,12 +318,21 @@ class ResultsCache(object):
       return None
 
   def _GetCacheDirForWrite(self):
-    return self._FormCacheDir(self._GetCacheKeyList(False))
+    return self._FormCacheDir(self._GetCacheKeyList(False))[0]
 
   def _FormCacheDir(self, list_of_strings):
     cache_key = " ".join(list_of_strings)
     cache_dir = misc.GetFilenameFromString(cache_key)
-    cache_path = os.path.join(SCRATCH_DIR, cache_dir)
+    if self.label.cache_dir:
+      cache_home = os.path.abspath(os.path.expanduser(self.label.cache_dir))
+      cache_path = [os.path.join(cache_home, cache_dir)]
+    else:
+      cache_path = [os.path.join(SCRATCH_DIR, cache_dir)]
+
+    for i in [x.strip() for x in self.share_users.split(",")]:
+      path = SCRATCH_BASE % i
+      cache_path.append(os.path.join(path, cache_dir))
+
     return cache_path
 
   def _GetCacheKeyList(self, read):
@@ -313,7 +343,7 @@ class ResultsCache(object):
     if read and CacheConditions.CHECKSUMS_MATCH not in self.cache_conditions:
       checksum = "*"
     else:
-      checksum = ImageChecksummer().Checksum(self.chromeos_image)
+      checksum = ImageChecksummer().Checksum(self.label)
 
     if read and CacheConditions.IMAGE_PATH_MATCH not in self.cache_conditions:
       image_path_checksum = "*"
diff --git a/crosperf/results_organizer.py b/crosperf/results_organizer.py
index 810186b2..2e5c9296 100644
--- a/crosperf/results_organizer.py
+++ b/crosperf/results_organizer.py
@@ -19,6 +19,11 @@ class ResultOrganizer(object):
     [
     ]}.
   """
+  key_filter = ["milliseconds_",
+                "retval",
+                "iterations",
+                "ms_",
+                "score_"]
 
   def __init__(self, benchmark_runs, labels, benchmarks=None):
     self.result = {}
@@ -43,7 +48,15 @@ class ResultOrganizer(object):
       cur_dict = cur_table[index]
       if not benchmark_run.result:
         continue
+      benchmark = benchmark_run.benchmark
+      key_filter_on = (benchmark.key_results_only and
+                       "PyAutoPerfTest" in benchmark.name + benchmark.autotest_name and
+                       "perf." not in benchmark.autotest_args)
       for autotest_key in benchmark_run.result.keyvals:
+        if (key_filter_on and
+            not any([key for key in self.key_filter if key in autotest_key])
+           ):
+          continue
         result_value = benchmark_run.result.keyvals[autotest_key]
         cur_dict[autotest_key] = result_value
     self._DuplicatePass()
diff --git a/crosperf/results_report.py b/crosperf/results_report.py
index f7434132..61c67d5b 100644
--- a/crosperf/results_report.py
+++ b/crosperf/results_report.py
@@ -11,6 +11,7 @@ from perf_table import PerfTable
 
 class ResultsReport(object):
   MAX_COLOR_CODE = 255
+  PERF_ROWS = 5
 
   def __init__(self, experiment):
     self.experiment = experiment
@@ -40,7 +41,13 @@ class ResultsReport(object):
                Column(AmeanResult(),
                       Format()),
                Column(StdResult(),
-                      Format())
+                      Format(), "StdDev"),
+               Column(CoeffVarResult(),
+                      CoeffVarFormat(), "StdDev/Mean"),
+               Column(GmeanRatioResult(),
+                      RatioFormat(), "GmeanSpeedup"),
+               Column(PValueResult(),
+                      PValueFormat(), "p-value")
               ]
     if not perf:
       return self._GetTables(self.labels, self.benchmark_runs, columns)
@@ -138,10 +145,12 @@ class ResultsReport(object):
       ben_table = self._GetTableHeader(ben)
       tables.append(ben_table)
       benchmark_data = p_table.perf_data[benchmark]
+      row_info = p_table.row_info[benchmark]
       table = []
       for event in benchmark_data:
-        tg = TableGenerator(benchmark_data[event], label_names)
-        table = tg.GetTable()
+        tg = TableGenerator(benchmark_data[event], label_names,
+                            sort=TableGenerator.SORT_BY_VALUES_DESC)
+        table = tg.GetTable(max(self.PERF_ROWS, row_info[event]))
         parsed_columns = self._ParseColumn(columns, ben.iterations)
         tf = TableFormatter(table, parsed_columns)
         tf.GenerateCellTable()
diff --git a/crosperf/settings_factory.py b/crosperf/settings_factory.py
index 11fa4b4b..924bc114 100644
--- a/crosperf/settings_factory.py
+++ b/crosperf/settings_factory.py
@@ -26,6 +26,12 @@ class BenchmarkSettings(Settings):
     self.AddField(FloatField("outlier_range", default=0.2,
                              description="The percentage of highest/lowest "
                              "values to omit when computing the average."))
+    self.AddField(BooleanField("rm_chroot_tmp", default=False,
+                               description="Whether remove the run_remote_test"
+                               "result in the chroot"))
+    self.AddField(BooleanField("key_results_only", default=True,
+                               description="Whether only show the key results"
+                               "of pyautoperf"))
     self.AddField(TextField("perf_args", default="",
                             description="The optional profile command. It "
                             "enables perf commands to record perforamance "
@@ -44,6 +50,8 @@ class LabelSettings(Settings):
                             "contains a src/scripts directory. Defaults to "
                             "the chromeos checkout which contains the "
                             "chromeos_image."))
+    self.AddField(TextField("md5sum", default="",
+                            description="The md5sum of this image"))
     self.AddField(TextField("board", required=True, description="The target "
                             "board for running experiments on, e.g. x86-alex."))
     self.AddField(ListField("remote", description=
@@ -53,6 +61,8 @@ class LabelSettings(Settings):
                             default="",
                             description="Extra arguments to pass to "
                             "image_chromeos.py."))
+    self.AddField(TextField("cache_dir", default="",
+                            description="The cache dir for this image."))
 
 
 class GlobalSettings(Settings):
@@ -69,6 +79,9 @@ class GlobalSettings(Settings):
     self.AddField(BooleanField("rerun_if_failed", description="Whether to "
                                "re-run failed autotest runs or not.",
                                default=False))
+    self.AddField(BooleanField("rm_chroot_tmp", default=False,
+                               description="Whether remove the run_remote_test"
+                               "result in the chroot"))
     self.AddField(ListField("email", description="Space-seperated"
                             "list of email addresses to send email to."))
     self.AddField(BooleanField("rerun", description="Whether to ignore the "
@@ -89,11 +102,27 @@ class GlobalSettings(Settings):
                             "contains a src/scripts directory. Defaults to "
                             "the chromeos checkout which contains the "
                             "chromeos_image."))
+    self.AddField(BooleanField("key_results_only", default=True,
+                               description="Whether only show the key results"
+                               "of pyautoperf"))
+    self.AddField(IntegerField("acquire_timeout", default=0,
+                               description="Number of seconds to wait for "
+                               "machine before exit if all the machines in "
+                               "the experiment file are busy. Default is 0"))
     self.AddField(TextField("perf_args", default="",
                             description="The optional profile command. It "
                             "enables perf commands to record perforamance "
                             "related counters. It must start with perf "
                             "command record or stat followed by arguments."))
+    self.AddField(TextField("cache_dir", default="",
+                            description="The abs path of cache dir. "
+                            "Default is /home/$(whoami)/cros_scratch."))
+    self.AddField(BooleanField("no_email", default=False,
+                               description="Whether to disable the email to "
+                               "user after crosperf finishes."))
+    self.AddField(TextField("share_users", default="",
+                            description="Who's cache data you want to "
+                            "use. It accepts multiple users seperated by \",\""))
 
 
 class SettingsFactory(object):
diff --git a/v14/cwp/bartlett/app.yaml b/cwp/bartlett/app.yaml
index 60010f70..60010f70 100644
--- a/v14/cwp/bartlett/app.yaml
+++ b/cwp/bartlett/app.yaml
diff --git a/v14/cwp/bartlett/server.py b/cwp/bartlett/server.py
index 3e4f1be7..3e4f1be7 100755
--- a/v14/cwp/bartlett/server.py
+++ b/cwp/bartlett/server.py
diff --git a/v14/cwp/bartlett/static/favicon.ico b/cwp/bartlett/static/favicon.ico
index 19b58c2e..19b58c2e 100644
--- a/v14/cwp/bartlett/static/favicon.ico
+++ b/cwp/bartlett/static/favicon.ico
diff --git a/v14/cwp/bartlett/test/server_tester.py b/cwp/bartlett/test/server_tester.py
index e5a2341d..e5a2341d 100644
--- a/v14/cwp/bartlett/test/server_tester.py
+++ b/cwp/bartlett/test/server_tester.py
diff --git a/v14/cwp/bartlett/update_appengine_server b/cwp/bartlett/update_appengine_server
index f3812057..f3812057 100755
--- a/v14/cwp/bartlett/update_appengine_server
+++ b/cwp/bartlett/update_appengine_server
diff --git a/v14/cwp/demo_pipeline.sh b/cwp/demo_pipeline.sh
index d45c5c44..d45c5c44 100644
--- a/v14/cwp/demo_pipeline.sh
+++ b/cwp/demo_pipeline.sh
diff --git a/v14/cwp/interpreter/app_engine_pull.py b/cwp/interpreter/app_engine_pull.py
index 65f67940..65f67940 100644
--- a/v14/cwp/interpreter/app_engine_pull.py
+++ b/cwp/interpreter/app_engine_pull.py
diff --git a/v14/cwp/interpreter/symbolizer.py b/cwp/interpreter/symbolizer.py
index 3e589538..3e589538 100644
--- a/v14/cwp/interpreter/symbolizer.py
+++ b/cwp/interpreter/symbolizer.py
diff --git a/v14/cwp/performance/experiment_gen.py b/cwp/performance/experiment_gen.py
index 7752c11e..7752c11e 100644
--- a/v14/cwp/performance/experiment_gen.py
+++ b/cwp/performance/experiment_gen.py
diff --git a/v14/dejagnu/__init__.py b/dejagnu/__init__.py
index e69de29b..e69de29b 100644
--- a/v14/dejagnu/__init__.py
+++ b/dejagnu/__init__.py
diff --git a/v14/dejagnu/boards/chromeos-machine.exp b/dejagnu/boards/chromeos-machine.exp
index b168b677..b168b677 100644
--- a/v14/dejagnu/boards/chromeos-machine.exp
+++ b/dejagnu/boards/chromeos-machine.exp
diff --git a/v14/dejagnu/chromeos.exp.in b/dejagnu/chromeos.exp.in
index 889653aa..889653aa 100644
--- a/v14/dejagnu/chromeos.exp.in
+++ b/dejagnu/chromeos.exp.in
diff --git a/v14/dejagnu/run_dejagnu.py b/dejagnu/run_dejagnu.py
index 8943bb20..8943bb20 100755
--- a/v14/dejagnu/run_dejagnu.py
+++ b/dejagnu/run_dejagnu.py
diff --git a/v14/dejagnu/site.exp b/dejagnu/site.exp
index beaa958d..beaa958d 100644
--- a/v14/dejagnu/site.exp
+++ b/dejagnu/site.exp
diff --git a/v14/fdo_scripts/divide_and_merge_profiles.py b/fdo_scripts/divide_and_merge_profiles.py
index c75e353a..c75e353a 100755
--- a/v14/fdo_scripts/divide_and_merge_profiles.py
+++ b/fdo_scripts/divide_and_merge_profiles.py
diff --git a/v14/fdo_scripts/divide_and_merge_profiles_test.py b/fdo_scripts/divide_and_merge_profiles_test.py
index f42db4e9..f42db4e9 100755
--- a/v14/fdo_scripts/divide_and_merge_profiles_test.py
+++ b/fdo_scripts/divide_and_merge_profiles_test.py
diff --git a/v14/fdo_scripts/profile_cycler.py b/fdo_scripts/profile_cycler.py
index efdafffa..efdafffa 100755
--- a/v14/fdo_scripts/profile_cycler.py
+++ b/fdo_scripts/profile_cycler.py
diff --git a/v14/fdo_scripts/summarize_hot_blocks.py b/fdo_scripts/summarize_hot_blocks.py
index c19f5477..c19f5477 100644
--- a/v14/fdo_scripts/summarize_hot_blocks.py
+++ b/fdo_scripts/summarize_hot_blocks.py
diff --git a/v14/fdo_scripts/vanilla_vs_fdo.py b/fdo_scripts/vanilla_vs_fdo.py
index 3cf5f4b6..3cf5f4b6 100644
--- a/v14/fdo_scripts/vanilla_vs_fdo.py
+++ b/fdo_scripts/vanilla_vs_fdo.py
diff --git a/v14/get_common_image_version.py b/get_common_image_version.py
index cdac8006..cdac8006 100755
--- a/v14/get_common_image_version.py
+++ b/get_common_image_version.py
diff --git a/image_chromeos.py b/image_chromeos.py
index 30b29a45..d5d5f7fe 100755
--- a/image_chromeos.py
+++ b/image_chromeos.py
@@ -171,6 +171,7 @@ def DoImage(argv):
                                                options.remote)
     logger.GetLogger().LogFatalIf(not successfully_imaged,
                                   "Image verification failed!")
+    TryRemountPartitionAsRW(options.chromeos_root, options.remote)
   else:
     l.LogOutput("Checksums match. Skipping reimage")
   return retval
@@ -268,6 +269,23 @@ def VerifyChromeChecksum(chromeos_root, image, remote):
   else:
     return False
 
+# Remount partition as writable.
+# TODO: auto-detect if an image is built using --noenable_rootfs_verification.
+def TryRemountPartitionAsRW(chromeos_root, remote):
+  l = logger.GetLogger()
+  cmd_executer = command_executer.GetCommandExecuter()
+  command = "sudo mount -o remount,rw /"
+  retval = cmd_executer.CrosRunCommand(\
+    command, chromeos_root=chromeos_root, machine=remote, terminated_timeout=10)
+  if retval:
+    ## Safely ignore.
+    l.LogWarning("Failed to remount partition as rw, "
+                 "probably the image was not built with "
+                 "\"--noenable_rootfs_verification\", "
+                 "you can safely ignore this.")
+  else:
+    l.LogOutput("Re-mounted partition as writable.")
+
 
 def EnsureMachineUp(chromeos_root, remote):
   l = logger.GetLogger()
diff --git a/v14/lock_machine.py b/lock_machine.py
index 0f948c3d..0f948c3d 100755
--- a/v14/lock_machine.py
+++ b/lock_machine.py
diff --git a/v14/lock_machine_test.py b/lock_machine_test.py
index d61878b8..d61878b8 100644
--- a/v14/lock_machine_test.py
+++ b/lock_machine_test.py
diff --git a/v14/produce_output.py b/produce_output.py
index 0e982bf7..0e982bf7 100755
--- a/v14/produce_output.py
+++ b/produce_output.py
diff --git a/v14/pyrun b/pyrun
index d9f5d75a..d9f5d75a 100755
--- a/v14/pyrun
+++ b/pyrun
diff --git a/v14/remote_gcc_build.py b/remote_gcc_build.py
index b2dfee38..b2dfee38 100755
--- a/v14/remote_gcc_build.py
+++ b/remote_gcc_build.py
diff --git a/v14/remote_kill_test.py b/remote_kill_test.py
index e56ef209..e56ef209 100755
--- a/v14/remote_kill_test.py
+++ b/remote_kill_test.py
diff --git a/v14/remote_test.py b/remote_test.py
index 2ef27f9d..2ef27f9d 100755
--- a/v14/remote_test.py
+++ b/remote_test.py
diff --git a/v14/repo_to_repo.py b/repo_to_repo.py
index 88433dfe..88433dfe 100755
--- a/v14/repo_to_repo.py
+++ b/repo_to_repo.py
diff --git a/v14/repo_to_repo_files/binutils-master.rtr b/repo_to_repo_files/binutils-master.rtr
index 7cb31941..7cb31941 100644
--- a/v14/repo_to_repo_files/binutils-master.rtr
+++ b/repo_to_repo_files/binutils-master.rtr
diff --git a/v14/repo_to_repo_files/binutils-mobile_toolchain_v16.rtr b/repo_to_repo_files/binutils-mobile_toolchain_v16.rtr
index 51f73cb2..51f73cb2 100644
--- a/v14/repo_to_repo_files/binutils-mobile_toolchain_v16.rtr
+++ b/repo_to_repo_files/binutils-mobile_toolchain_v16.rtr
diff --git a/v14/repo_to_repo_files/crosperf.rtr b/repo_to_repo_files/crosperf.rtr
index 0efb1cde..0efb1cde 100644
--- a/v14/repo_to_repo_files/crosperf.rtr
+++ b/repo_to_repo_files/crosperf.rtr
diff --git a/v14/repo_to_repo_files/gcc-branches_google_4_7.rtr b/repo_to_repo_files/gcc-branches_google_4_7.rtr
index ec7fcf34..ec7fcf34 100644
--- a/v14/repo_to_repo_files/gcc-branches_google_4_7.rtr
+++ b/repo_to_repo_files/gcc-branches_google_4_7.rtr
diff --git a/v14/repo_to_repo_files/gcc-branches_google_main.rtr b/repo_to_repo_files/gcc-branches_google_main.rtr
index 289f531b..289f531b 100644
--- a/v14/repo_to_repo_files/gcc-branches_google_main.rtr
+++ b/repo_to_repo_files/gcc-branches_google_main.rtr
diff --git a/v14/repo_to_repo_files/gcc-master.rtr b/repo_to_repo_files/gcc-master.rtr
index 82a91c01..82a91c01 100644
--- a/v14/repo_to_repo_files/gcc-master.rtr
+++ b/repo_to_repo_files/gcc-master.rtr
diff --git a/v14/repo_to_repo_files/gdb-master.rtr b/repo_to_repo_files/gdb-master.rtr
index c29e36e0..c29e36e0 100644
--- a/v14/repo_to_repo_files/gdb-master.rtr
+++ b/repo_to_repo_files/gdb-master.rtr
diff --git a/v14/repo_to_repo_files/toolchain-utils.rtr b/repo_to_repo_files/toolchain-utils.rtr
index 09a74730..09a74730 100644
--- a/v14/repo_to_repo_files/toolchain-utils.rtr
+++ b/repo_to_repo_files/toolchain-utils.rtr
diff --git a/v14/report_generator.py b/report_generator.py
index a5f11ca6..a5f11ca6 100755
--- a/v14/report_generator.py
+++ b/report_generator.py
diff --git a/v14/run_benchmarks.py b/run_benchmarks.py
index 9dc49004..9dc49004 100755
--- a/v14/run_benchmarks.py
+++ b/run_benchmarks.py
diff --git a/v14/run_tests.py b/run_tests.py
index 075f29b1..075f29b1 100755
--- a/v14/run_tests.py
+++ b/run_tests.py
diff --git a/v14/setup_chromeos.py b/setup_chromeos.py
index 7d3c22da..7d3c22da 100755
--- a/v14/setup_chromeos.py
+++ b/setup_chromeos.py
diff --git a/v14/sheriff_rotation.py b/sheriff_rotation.py
index 4ccf896d..4ccf896d 100755
--- a/v14/sheriff_rotation.py
+++ b/sheriff_rotation.py
diff --git a/v14/summarize_results.py b/summarize_results.py
index 3e561f3b..3e561f3b 100755
--- a/v14/summarize_results.py
+++ b/summarize_results.py
diff --git a/v14/tc_enter_chroot.py b/tc_enter_chroot.py
index 50eb312c..50eb312c 100755
--- a/v14/tc_enter_chroot.py
+++ b/tc_enter_chroot.py
diff --git a/v14/test_gcc_dejagnu.py b/test_gcc_dejagnu.py
index 0edf2cb9..0edf2cb9 100755
--- a/v14/test_gcc_dejagnu.py
+++ b/test_gcc_dejagnu.py
diff --git a/v14/test_toolchains.py b/test_toolchains.py
index 18448ab2..18448ab2 100644
--- a/v14/test_toolchains.py
+++ b/test_toolchains.py
diff --git a/v14/utils/buildbot_json.py b/utils/buildbot_json.py
index 6ea7f8fb..6ea7f8fb 100755
--- a/v14/utils/buildbot_json.py
+++ b/utils/buildbot_json.py
diff --git a/utils/command_executer.py b/utils/command_executer.py
index 3edb6262..0aedc47c 100644
--- a/utils/command_executer.py
+++ b/utils/command_executer.py
@@ -74,11 +74,14 @@ class CommandExecuter:
     out = err = None
     pipes = [p.stdout, p.stderr]
 
+    my_poll = select.poll()
+    my_poll.register(p.stdout, select.POLLIN)
+    my_poll.register(p.stderr, select.POLLIN)
+
     terminated_time = None
     started_time = time.time()
 
     while len(pipes):
-      fds = select.select(pipes, [], [], 0.1)
       if command_terminator and command_terminator.IsTerminated():
         self.RunCommand("sudo kill -9 " + str(p.pid),
                         print_to_console=print_to_console)
@@ -88,21 +91,25 @@ class CommandExecuter:
           return (p.wait, full_stdout, full_stderr)
         else:
           return wait
-      for fd in fds[0]:
-        if fd == p.stdout:
+
+      l=my_poll.poll(100)
+      for (fd, evt) in l:
+        if fd == p.stdout.fileno():
           out = os.read(p.stdout.fileno(), 16384)
           if return_output:
             full_stdout += out
           self.logger.LogCommandOutput(out, print_to_console)
           if out == "":
             pipes.remove(p.stdout)
-        if fd == p.stderr:
+            my_poll.unregister(p.stdout)
+        if fd == p.stderr.fileno():
           err = os.read(p.stderr.fileno(), 16384)
           if return_output:
             full_stderr += err
           self.logger.LogCommandError(err, print_to_console)
           if err == "":
             pipes.remove(p.stderr)
+            my_poll.unregister(p.stderr)
 
       if p.poll() is not None:
         if terminated_time is None:
diff --git a/v14/utils/command_executer_unittest.py b/utils/command_executer_unittest.py
index ea0e918c..ea0e918c 100755
--- a/v14/utils/command_executer_unittest.py
+++ b/utils/command_executer_unittest.py
diff --git a/utils/logger.py b/utils/logger.py
index faad9666..99c679ab 100644
--- a/utils/logger.py
+++ b/utils/logger.py
@@ -167,17 +167,19 @@ class Logger(object):
 main_logger = None
 
 
-def InitLogger(script_name, print_console=True):
+def InitLogger(script_name, log_dir, print_console=True):
   """Initialize a global logger. To be called only once."""
   global main_logger
   assert not main_logger, "The logger has already been initialized"
   rootdir, basefilename = GetRoot(script_name)
-  main_logger = Logger(rootdir, basefilename, print_console)
+  if not log_dir:
+    log_dir = rootdir
+  main_logger = Logger(log_dir, basefilename, print_console)
 
 
-def GetLogger():
+def GetLogger(log_dir=""):
   if not main_logger:
-    InitLogger(sys.argv[0])
+    InitLogger(sys.argv[0], log_dir)
   return main_logger
 
 
diff --git a/utils/misc.py b/utils/misc.py
index 40622512..175a6e07 100644
--- a/utils/misc.py
+++ b/utils/misc.py
@@ -145,19 +145,25 @@ def DoesLabelExist(chromeos_root, board, label):
   return os.path.exists(image_label)
 
 
-def GetBuildPackagesCommand(board, usepkg=False):
+def GetBuildPackagesCommand(board, usepkg=False, debug=False):
   if usepkg:
     usepkg_flag = "--usepkg"
   else:
     usepkg_flag = "--nousepkg"
+  if debug:
+    withdebug_flag = '--withdebug'
+  else:
+    withdebug_flag = '--nowithdebug'
   return ("./build_packages %s --withdev --withtest --withautotest "
-          "--skip_toolchain_update --nowithdebug --board=%s" %
-          (usepkg_flag, board))
-
+          "--skip_toolchain_update %s --board=%s" %
+          (usepkg_flag, withdebug_flag, board))
 
-def GetBuildImageCommand(board):
-  return "./build_image --board=%s test" % board
 
+def GetBuildImageCommand(board, dev=False):
+  dev_args = ""
+  if dev:
+    dev_args = "--noenable_rootfs_verification --disk_layout=2gb-rootfs"
+  return "./build_image --board=%s %s test" % (board, dev_args)
 
 def GetSetupBoardCommand(board, gcc_version=None, binutils_version=None,
                          usepkg=None, force=None):
@@ -252,14 +258,17 @@ def AcquireLock(lock_file, timeout=1200):
   abs_path = os.path.abspath(lock_file)
   dir_path = os.path.dirname(abs_path)
   sleep_time = min(10, timeout/10.0)
+  reason = "pid: {0}, commad: {1}".format(os.getpid(),
+                                          sys.argv[0])
   if not os.path.exists(dir_path):
     try:
-      os.makedirs(dir_path)
+      with lock_machine.FileCreationMask(0002):
+        os.makedirs(dir_path)
     except OSError:
       print "Cannot create dir {0}, exiting...".format(dir_path)
       exit(0)
   while True:
-    locked = (lock_machine.Lock(lock_file).NonBlockingLock(True, sys.argv[0]))
+    locked = (lock_machine.Lock(lock_file).NonBlockingLock(True, reason))
     if locked:
       break
     time.sleep(sleep_time)
diff --git a/utils/perf_diff.py b/utils/perf_diff.py
index cfe90a9b..d56eba16 100755
--- a/utils/perf_diff.py
+++ b/utils/perf_diff.py
@@ -15,16 +15,20 @@ import sys
 import misc
 import tabulator
 
+ROWS_TO_SHOW = "Rows_to_show_in_the_perf_table"
 
-def GetPerfDictFromReport(report_file, num_functions=5):
+def GetPerfDictFromReport(report_file):
   output = {}
   perf_report = PerfReport(report_file)
   for k, v in perf_report.sections.items():
     if k not in output:
       output[k] = {}
-    for function in v.functions[:num_functions]:
+    output[k][ROWS_TO_SHOW] = 0
+    for function in v.functions:
       out_key = "%s" % (function.name)
       output[k][out_key] = function.count
+      if function.percent > 1:
+        output[k][ROWS_TO_SHOW] += 1
   return output
 
 
@@ -85,6 +89,7 @@ class Function(object):
   def __init__(self):
     self.count = 0
     self.name = ""
+    self.percent = 0
 
 
 class Section(object):
@@ -110,6 +115,7 @@ class Section(object):
       if not line.startswith("#"):
         fields = [f for f in line.split(" ") if f]
         function = Function()
+        function.percent = float(fields[0].strip("%"))
         function.count = int(fields[1])
         function.name = " ".join(fields[2:])
         self.functions.append(function)
@@ -164,7 +170,7 @@ class PerfReport(object):
 
   def _SplitSections(self):
     self._section_contents = []
-    indices = [m.start() for m in re.finditer("Events:", self._perf_contents)]
+    indices = [m.start() for m in re.finditer("# Events:", self._perf_contents)]
     indices.append(len(self._perf_contents))
     for i in range(len(indices) - 1):
       section_content = self._perf_contents[indices[i]:indices[i+1]]
diff --git a/utils/tabulator.py b/utils/tabulator.py
index ed83a04b..f75419ab 100644
--- a/utils/tabulator.py
+++ b/utils/tabulator.py
@@ -2,8 +2,69 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+"""Table generating, analyzing and printing functions.
+
+This defines several classes that are used to generate, analyze and print
+tables.
+
+Example usage:
+
+  from utils import tabulator
+
+  data = [["benchmark1", "33", "44"],["benchmark2", "44", "33"]]
+  tabulator.GetSimpleTable(data)
+
+You could also use it to generate more complex tables with analysis such as
+p-values, custom colors, etc. Tables are generated by TableGenerator and
+analyzed/formatted by TableFormatter. TableFormatter can take in a list of
+columns with custom result computation and coloring, and will compare values in
+each row according to taht scheme. Here is a complex example on printing a
+table:
+
+  from utils import tabulator
+
+  runs = [[{"k1": "10", "k2": "12", "k5": "40", "k6": "40",
+            "ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
+            "k10": "0"},
+           {"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
+            "k9": "FAIL", "k10": "0"}],
+          [{"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
+            "45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
+            "PASS"}]]
+  labels = ["vanilla", "modified"]
+  tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
+  table = tg.GetTable()
+  columns = [Column(LiteralResult(),
+                    Format(),
+                    "Literal"),
+             Column(AmeanResult(),
+                    Format()),
+             Column(StdResult(),
+                    Format()),
+             Column(CoeffVarResult(),
+                    CoeffVarFormat()),
+             Column(NonEmptyCountResult(),
+                    Format()),
+             Column(AmeanRatioResult(),
+                    PercentFormat()),
+             Column(AmeanRatioResult(),
+                    RatioFormat()),
+             Column(GmeanRatioResult(),
+                    RatioFormat()),
+             Column(PValueResult(),
+                    PValueFormat()),
+            ]
+  tf = TableFormatter(table, columns)
+  cell_table = tf.GetCellTable()
+  tp = TablePrinter(cell_table, out_to)
+  print tp.Print()
+
+"""
+
+
 import getpass
 import math
+import sys
 import numpy
 
 import colortrans
@@ -58,8 +119,10 @@ class TableGenerator(object):
       for run in run_list:
         if key in run:
           values.append(run[key])
-    ret = max(_StripNone(values))
-    return ret
+    values = _StripNone(values)
+    if _AllFloat(values):
+      values = _GetFloats(values)
+    return max(values)
 
   def _GetLowestValue(self, key):
     values = []
@@ -67,15 +130,19 @@ class TableGenerator(object):
       for run in run_list:
         if key in run:
           values.append(run[key])
-    ret = min(_StripNone(values))
-    return ret
+    values = _StripNone(values)
+    if _AllFloat(values):
+      values = _GetFloats(values)
+    return min(values)
 
   def _SortKeys(self, keys):
     if self._sort == self.SORT_BY_KEYS:
       return sorted(keys)
     elif self._sort == self.SORT_BY_VALUES:
+      # pylint: disable=unnecessary-lambda
       return sorted(keys, key=lambda x: self._GetLowestValue(x))
     elif self._sort == self.SORT_BY_VALUES_DESC:
+      # pylint: disable=unnecessary-lambda
       return sorted(keys, key=lambda x: self._GetHighestValue(x), reverse=True)
     else:
       assert 0, "Unimplemented sort %s" % self._sort
@@ -84,7 +151,7 @@ class TableGenerator(object):
     keys = self._AggregateKeys()
     return self._SortKeys(keys)
 
-  def GetTable(self):
+  def GetTable(self, number_of_rows=sys.maxint):
     """Returns a table from a list of list of dicts.
 
     The list of list of dicts is passed into the constructor of TableGenerator.
@@ -92,7 +159,7 @@ class TableGenerator(object):
     table of values.
 
     Args:
-      None
+      number_of_rows: Maximum number of rows to return from the table.
     Returns:
       A list of lists which is the table.
 
@@ -113,6 +180,7 @@ class TableGenerator(object):
     keys = self._GetKeys()
     header = [self._key_name] + self._labels
     table = [header]
+    rows = 0
     for k in keys:
       row = [k]
       for run_list in self._runs:
@@ -124,6 +192,9 @@ class TableGenerator(object):
             v.append(None)
         row.append(v)
       table.append(row)
+      rows += 1
+      if rows == number_of_rows:
+        break
     return table
 
 
@@ -144,6 +215,7 @@ class Result(object):
   def NeedsBaseline(self):
     return False
 
+  # pylint: disable=unused-argument
   def _Literal(self, cell, values, baseline_values):
     cell.value = " ".join([str(v) for v in values])
 
@@ -178,7 +250,7 @@ class Result(object):
     """
     all_floats = True
     values = _StripNone(values)
-    if not len(values):
+    if not values:
       cell.value = ""
       return
     if _AllFloat(values):
@@ -211,16 +283,25 @@ class LiteralResult(Result):
 
   def Compute(self, cell, values, baseline_values):
     try:
-      if values[self.iteration]:
-        cell.value = values[self.iteration]
-      else:
-        cell.value = "-"
+      cell.value = values[self.iteration]
     except IndexError:
       cell.value = "-"
 
 
 class NonEmptyCountResult(Result):
+  """A class that counts the number of non-empty results.
+
+  The number of non-empty values will be stored in the cell.
+  """
+
   def Compute(self, cell, values, baseline_values):
+    """Put the number of non-empty values in the cell result.
+
+    Args:
+      cell: Put the result in cell.value.
+      values: A list of values for the row.
+      baseline_values: A list of baseline values for the row.
+    """
     cell.value = len(_StripNone(values))
     if not baseline_values:
       return
@@ -231,8 +312,8 @@ class NonEmptyCountResult(Result):
     len_values = len(values)
     len_baseline_values = len(baseline_values)
     tmp_cell = Cell()
-    tmp_cell.value= 1.0 + (float(cell.value - base_value) /
-                         (max(len_values, len_baseline_values)))
+    tmp_cell.value = 1.0 + (float(cell.value - base_value) /
+                            (max(len_values, len_baseline_values)))
     f.Compute(tmp_cell)
     cell.bgcolor = tmp_cell.bgcolor
 
@@ -244,6 +325,7 @@ class StringMeanResult(Result):
     else:
       cell.value = "?"
 
+
 class AmeanResult(StringMeanResult):
   def _ComputeFloat(self, cell, values, baseline_values):
     cell.value = numpy.mean(values)
@@ -316,7 +398,7 @@ class PValueResult(ComparisonResult):
     if len(values) < 2 or len(baseline_values) < 2:
       cell.value = float("nan")
       return
-    import stats
+    import stats  # pylint: disable=g-import-not-at-top
     _, cell.value = stats.lttest_ind(values, baseline_values)
 
   def _ComputeString(self, cell, values, baseline_values):
@@ -462,12 +544,11 @@ class PValueFormat(Format):
     cell.string_value = "%0.2f" % float(cell.value)
     if float(cell.value) < 0.05:
       cell.bgcolor = self._GetColor(cell.value,
-                                  Color(255, 255, 0, 0),
-                                  Color(255, 255, 255, 0),
-                                  Color(255, 255, 255, 0),
-                                  mid_value=0.05,
-                                  power=1)
-      cell.bgcolor_row = True
+                                    Color(255, 255, 0, 0),
+                                    Color(255, 255, 255, 0),
+                                    Color(255, 255, 255, 0),
+                                    mid_value=0.05,
+                                    power=1)
 
 
 class StorageFormat(Format):
@@ -802,6 +883,7 @@ class TablePrinter(object):
     if self._output_type == self.CONSOLE:
       rgb = color.GetRGB()
       prefix, _ = colortrans.rgb2short(rgb)
+      # pylint: disable=anomalous-backslash-in-string
       prefix = "\033[48;5;%sm" % prefix
       suffix = "\033[0m"
     elif self._output_type in [self.EMAIL, self.HTML]:
@@ -818,6 +900,7 @@ class TablePrinter(object):
     if self._output_type == self.CONSOLE:
       rgb = color.GetRGB()
       prefix, _ = colortrans.rgb2short(rgb)
+      # pylint: disable=anomalous-backslash-in-string
       prefix = "\033[38;5;%sm" % prefix
       suffix = "\033[0m"
     elif self._output_type in [self.EMAIL, self.HTML]:
@@ -965,7 +1048,21 @@ def GetSimpleTable(table, out_to=TablePrinter.CONSOLE):
   return tp.Print()
 
 
+# pylint: disable=redefined-outer-name
 def GetComplexTable(runs, labels, out_to=TablePrinter.CONSOLE):
+  """Prints a complex table.
+
+  This can be used to generate a table with arithmetic mean, standard deviation,
+  coefficient of variation, p-values, etc.
+
+  Args:
+    runs: A list of lists with data to tabulate.
+    labels: A list of labels that correspond to the runs.
+    out_to: specifies the format of the table (example CONSOLE or HTML).
+
+  Returns:
+    A string table that can be printed to the console or put in an HTML file.
+  """
   tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
   table = tg.GetTable()
   columns = [Column(LiteralResult(),
@@ -995,33 +1092,21 @@ def GetComplexTable(runs, labels, out_to=TablePrinter.CONSOLE):
 
 if __name__ == "__main__":
   # Run a few small tests here.
-  runs = [
-      [
-          {"k1": "10", "k2": "12", "k5": "40", "k6": "40",
-           "ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
-           "k10": "0"},
-          {"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
-           "k9": "FAIL", "k10": "0"}
-          ],
-      [
-          {"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
-           "45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
-           "PASS"},
-          ],
-      ]
+  runs = [[{"k1": "10", "k2": "12", "k5": "40", "k6": "40",
+            "ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
+            "k10": "0"},
+           {"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
+            "k9": "FAIL", "k10": "0"}],
+          [{"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
+            "45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
+            "PASS"}]]
   labels = ["vanilla", "modified"]
   t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
   print t
   email = GetComplexTable(runs, labels, TablePrinter.EMAIL)
 
-  runs = [
-      [
-          {"k1": "1",}, {"k1": "1.1"}, {"k1": "1.2"},
-          ],
-      [
-          {"k1": "5",}, {"k1": "5.1"}, {"k1": "5.2"},
-          ],
-      ]
+  runs = [[{"k1": "1"}, {"k1": "1.1"}, {"k1": "1.2"}],
+          [{"k1": "5"}, {"k1": "5.1"}, {"k1": "5.2"}]]
   t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
   print t
 
diff --git a/utils/tabulator_test.py b/utils/tabulator_test.py
index 54b455d3..16406107 100644
--- a/utils/tabulator_test.py
+++ b/utils/tabulator_test.py
@@ -1,6 +1,6 @@
 # Copyright 2012 Google Inc. All Rights Reserved.
 
-"""Tests for misc."""
+"""Tests for the tabulator module."""
 
 __author__ = "asharif@google.com (Ahmad Sharif)"
 
@@ -69,7 +69,7 @@ class TabulatorTest(unittest.TestCase):
   def testTableGenerator(self):
     runs = [[{"k1": "10", "k2": "12"},
              {"k1": "13", "k2": "14", "k3": "15"}],
-            [{"k1": "50", "k2": "51", "k3": "52", "k4": "53"},]]
+            [{"k1": "50", "k2": "51", "k3": "52", "k4": "53"}]]
     labels = ["vanilla", "modified"]
     tg = tabulator.TableGenerator(runs, labels)
     table = tg.GetTable()
diff --git a/v14/README b/v14/README
deleted file mode 100644
index 3ab3d7b7..00000000
--- a/v14/README
+++ /dev/null
@@ -1,10 +0,0 @@
-To run scripts in this directory, first run:
-
-export PYTHONPATH=$(readlink -f .):$PYTHONPATH
-
-from this directory.
-
-Then you can run any script.
-
-To get help on any script, type in python <script> --help, or refer to the
-header of the script for more information.
diff --git a/v14/crosperf/autotest_runner.py b/v14/crosperf/autotest_runner.py
deleted file mode 100644
index 5611b655..00000000
--- a/v14/crosperf/autotest_runner.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-from utils import command_executer
-
-
-class AutotestRunner(object):
-  """ This defines the interface from crosperf to ./run_remote_tests.sh.
-  """
-  def __init__(self, logger_to_use=None):
-    self._logger = logger_to_use
-    self._ce = command_executer.GetCommandExecuter(self._logger)
-    self._ct = command_executer.CommandTerminator()
-
-  def Run(self, machine_name, chromeos_root, board, autotest_name,
-          autotest_args):
-    """Run the run_remote_test."""
-    options = ""
-    if board:
-      options += " --board=%s" % board
-    if autotest_args:
-      options += " %s" % autotest_args
-    command = "rm -rf /usr/local/autotest/results/*"
-    self._ce.CrosRunCommand(command, machine=machine_name, username="root",
-                            chromeos_root=chromeos_root)
-    command = ("./run_remote_tests.sh --remote=%s %s %s" %
-               (machine_name, options, autotest_name))
-    return self._ce.ChrootRunCommand(chromeos_root, command, True, self._ct)
-
-  def Terminate(self):
-    self._ct.Terminate()
-
-
-class MockAutotestRunner(object):
-  def __init__(self):
-    pass
-
-  def Run(self, *args):
-    return ["", "", 0]
diff --git a/v14/crosperf/benchmark.py b/v14/crosperf/benchmark.py
deleted file mode 100644
index 8fe8a492..00000000
--- a/v14/crosperf/benchmark.py
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-
-class Benchmark(object):
-  """Class representing a benchmark to be run.
-
-  Contains details of the autotest, arguments to pass to the autotest,
-  iterations to run the autotest and so on. Note that the benchmark name
-  can be different to the autotest name. For example, you may want to have
-  two different benchmarks which run the same autotest with different
-  arguments.
-  """
-
-  def __init__(self, name, autotest_name, autotest_args, iterations,
-               outlier_range, key_results_only, rm_chroot_tmp, perf_args):
-    self.name = name
-    self.autotest_name = autotest_name
-    self.autotest_args = autotest_args
-    self.iterations = iterations
-    self.outlier_range = outlier_range
-    self.perf_args = perf_args
-    self.key_results_only = key_results_only
-    self.rm_chroot_tmp = rm_chroot_tmp
-    self.iteration_adjusted = False
diff --git a/v14/crosperf/benchmark_run.py b/v14/crosperf/benchmark_run.py
deleted file mode 100644
index 80c95c4d..00000000
--- a/v14/crosperf/benchmark_run.py
+++ /dev/null
@@ -1,198 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import datetime
-import os
-import threading
-import time
-import traceback
-
-from utils import command_executer
-from utils import timeline
-
-from autotest_runner import AutotestRunner
-from results_cache import Result
-from results_cache import ResultsCache
-
-STATUS_FAILED = "FAILED"
-STATUS_SUCCEEDED = "SUCCEEDED"
-STATUS_IMAGING = "IMAGING"
-STATUS_RUNNING = "RUNNING"
-STATUS_WAITING = "WAITING"
-STATUS_PENDING = "PENDING"
-
-
-class BenchmarkRun(threading.Thread):
-  def __init__(self, name, benchmark,
-               label,
-               iteration,
-               cache_conditions,
-               machine_manager,
-               logger_to_use,
-               share_users):
-    threading.Thread.__init__(self)
-    self.name = name
-    self._logger = logger_to_use
-    self.benchmark = benchmark
-    self.iteration = iteration
-    self.label = label
-    self.result = None
-    self.terminated = False
-    self.retval = None
-    self.run_completed = False
-    self.machine_manager = machine_manager
-    self.cache = ResultsCache()
-    self.autotest_runner = AutotestRunner(self._logger)
-    self.machine = None
-    self.cache_conditions = cache_conditions
-    self.runs_complete = 0
-    self.cache_hit = False
-    self.failure_reason = ""
-    self.autotest_args = "%s %s" % (benchmark.autotest_args,
-                                    self._GetExtraAutotestArgs())
-    self._ce = command_executer.GetCommandExecuter(self._logger)
-    self.timeline = timeline.Timeline()
-    self.timeline.Record(STATUS_PENDING)
-    self.share_users = share_users
-
-  def run(self):
-    try:
-      # Just use the first machine for running the cached version,
-      # without locking it.
-      self.cache.Init(self.label.chromeos_image,
-                      self.label.chromeos_root,
-                      self.benchmark.autotest_name,
-                      self.iteration,
-                      self.autotest_args,
-                      self.machine_manager,
-                      self.label.board,
-                      self.cache_conditions,
-                      self._logger,
-                      self.label,
-                      self.share_users
-                     )
-
-      self.result = self.cache.ReadResult()
-      self.cache_hit = (self.result is not None)
-
-      if self.result:
-        self._logger.LogOutput("%s: Cache hit." % self.name)
-        self._logger.LogOutput(self.result.out, print_to_console=False)
-        self._logger.LogError(self.result.err, print_to_console=False)
-
-      else:
-        self._logger.LogOutput("%s: No cache hit." % self.name)
-        self.timeline.Record(STATUS_WAITING)
-        # Try to acquire a machine now.
-        self.machine = self.AcquireMachine()
-        self.cache.remote = self.machine.name
-        self.result = self.RunTest(self.machine)
-        self.cache.StoreResult(self.result)
-
-      if self.terminated:
-        return
-
-      if not self.result.retval:
-        self.timeline.Record(STATUS_SUCCEEDED)
-      else:
-        if self.timeline.GetLastEvent() != STATUS_FAILED:
-          self.failure_reason = "Return value of autotest was non-zero."
-          self.timeline.Record(STATUS_FAILED)
-
-    except Exception, e:
-      self._logger.LogError("Benchmark run: '%s' failed: %s" % (self.name, e))
-      traceback.print_exc()
-      if self.timeline.GetLastEvent() != STATUS_FAILED:
-        self.timeline.Record(STATUS_FAILED)
-        self.failure_reason = str(e)
-    finally:
-      if self.machine:
-        self._logger.LogOutput("Releasing machine: %s" % self.machine.name)
-        self.machine_manager.ReleaseMachine(self.machine)
-        self._logger.LogOutput("Released machine: %s" % self.machine.name)
-
-  def Terminate(self):
-    self.terminated = True
-    self.autotest_runner.Terminate()
-    if self.timeline.GetLastEvent() != STATUS_FAILED:
-      self.timeline.Record(STATUS_FAILED)
-      self.failure_reason = "Thread terminated."
-
-  def AcquireMachine(self):
-    while True:
-      if self.terminated:
-        raise Exception("Thread terminated while trying to acquire machine.")
-      machine = self.machine_manager.AcquireMachine(self.label.chromeos_image,
-                                                    self.label)
-
-      if machine:
-        self._logger.LogOutput("%s: Machine %s acquired at %s" %
-                               (self.name,
-                                machine.name,
-                                datetime.datetime.now()))
-        break
-      else:
-        sleep_duration = 10
-        time.sleep(sleep_duration)
-    return machine
-
-  def _GetExtraAutotestArgs(self):
-    if self.benchmark.perf_args:
-      perf_args_list = self.benchmark.perf_args.split(" ")
-      perf_args_list = [perf_args_list[0]] + ["-a"] + perf_args_list[1:]
-      perf_args = " ".join(perf_args_list)
-      if not perf_args_list[0] in ["record", "stat"]:
-        raise Exception("perf_args must start with either record or stat")
-      extra_autotest_args = ["--profiler=custom_perf",
-                             ("--profiler_args='perf_options=\"%s\"'" %
-                              perf_args)]
-      return " ".join(extra_autotest_args)
-    else:
-      return ""
-
-  def RunTest(self, machine):
-    self.timeline.Record(STATUS_IMAGING)
-    self.machine_manager.ImageMachine(machine,
-                                      self.label)
-    self.timeline.Record(STATUS_RUNNING)
-    [retval, out, err] = self.autotest_runner.Run(machine.name,
-                                                  self.label.chromeos_root,
-                                                  self.label.board,
-                                                  self.benchmark.autotest_name,
-                                                  self.autotest_args)
-    self.run_completed = True
-
-    return Result.CreateFromRun(self._logger,
-                                self.label.chromeos_root,
-                                self.label.board,
-                                self.label.name,
-                                out,
-                                err,
-                                retval)
-
-  def SetCacheConditions(self, cache_conditions):
-    self.cache_conditions = cache_conditions
-
-
-class MockBenchmarkRun(BenchmarkRun):
-  """Inherited from BenchmarkRun, just overide RunTest for testing."""
-
-  def RunTest(self, machine):
-    """Remove Result.CreateFromRun for testing."""
-    self.timeline.Record(STATUS_IMAGING)
-    self.machine_manager.ImageMachine(machine,
-                                      self.label)
-    self.timeline.Record(STATUS_RUNNING)
-    [retval, out, err] = self.autotest_runner.Run(machine.name,
-                                                  self.label.chromeos_root,
-                                                  self.label.board,
-                                                  self.benchmark.autotest_name,
-                                                  self.autotest_args)
-    self.run_completed = True
-    rr = Result("Results placed in /tmp/test", "", 0)
-    rr.out = out
-    rr.err = err
-    rr.retval = retval
-    return rr
-
diff --git a/v14/crosperf/benchmark_run_unittest.py b/v14/crosperf/benchmark_run_unittest.py
deleted file mode 100755
index 47e027f4..00000000
--- a/v14/crosperf/benchmark_run_unittest.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""Testing of benchmark_run."""
-
-import unittest
-
-from utils import logger
-
-from autotest_runner import MockAutotestRunner
-from benchmark_run import MockBenchmarkRun
-from label import MockLabel
-from benchmark import Benchmark
-from machine_manager import MockMachineManager
-from results_cache import MockResultsCache
-
-
-class BenchmarkRunTest(unittest.TestCase):
-  def testDryRun(self):
-    my_label = MockLabel("test1", "image1", "/tmp/test_benchmark_run",
-                         "x86-alex", "chromeos-alex1",
-                         image_args="",
-                         image_md5sum="",
-                         cache_dir="")
-    m = MockMachineManager("/tmp/chromeos_root", 0)
-    m.AddMachine("chromeos-alex1")
-    bench = Benchmark("PageCyler",
-                      "Pyautoperf",
-                      "",
-                      1,
-                      0.2,
-                      False,
-                      False,
-                      "")
-    b = MockBenchmarkRun("test run",
-                         bench,
-                         my_label,
-                         1,
-                         [],
-                         m,
-                         logger.GetLogger(),
-                         "")
-    b.cache = MockResultsCache()
-    b.autotest_runner = MockAutotestRunner()
-    b.start()
-
-
-if __name__ == "__main__":
-  unittest.main()
diff --git a/v14/crosperf/column_chart.py b/v14/crosperf/column_chart.py
deleted file mode 100644
index 22a45c5b..00000000
--- a/v14/crosperf/column_chart.py
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-
-class ColumnChart(object):
-  def __init__(self, title, width, height):
-    self.title = title
-    self.chart_div = filter(str.isalnum, title)
-    self.width = width
-    self.height = height
-    self.columns = []
-    self.rows = []
-    self.series = []
-
-  def AddSeries(self, column_name, series_type, color):
-    for i in range(len(self.columns)):
-      if column_name == self.columns[i][1]:
-        self.series.append((i - 1, series_type, color))
-        break
-
-  def AddColumn(self, name, column_type):
-    self.columns.append((column_type, name))
-
-  def AddRow(self, row):
-    self.rows.append(row)
-
-  def GetJavascript(self):
-    res = "var data = new google.visualization.DataTable();\n"
-    for column in self.columns:
-      res += "data.addColumn('%s', '%s');\n" % column
-    res += "data.addRows(%s);\n" % len(self.rows)
-    for row in range(len(self.rows)):
-      for column in range(len(self.columns)):
-        val = self.rows[row][column]
-        if isinstance(val, str):
-          val = "'%s'" % val
-        res += "data.setValue(%s, %s, %s);\n" % (row, column, val)
-
-    series_javascript = ""
-    for series in self.series:
-      series_javascript += "%s: {type: '%s', color: '%s'}, " % series
-
-    chart_add_javascript = """
-var chart_%s = new google.visualization.ComboChart(
-  document.getElementById('%s'));
-chart_%s.draw(data, {width: %s, height: %s, title: '%s', legend: 'none',
-  seriesType: "bars", lineWidth: 0, pointSize: 5, series: {%s},
-  vAxis: {minValue: 0}})
-"""
-    res += chart_add_javascript % (self.chart_div, self.chart_div,
-                                   self.chart_div, self.width,
-                                   self.height, self.title, series_javascript)
-    return res
-
-  def GetDiv(self):
-    return "<div id='%s' class='chart'></div>" % self.chart_div
diff --git a/v14/crosperf/crosperf b/v14/crosperf/crosperf
deleted file mode 100755
index 904a172a..00000000
--- a/v14/crosperf/crosperf
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-PYTHONPATH=$(dirname $0)/..:$PYTHONPATH python $(dirname $0)/crosperf.py "$@"
diff --git a/v14/crosperf/crosperf.py b/v14/crosperf/crosperf.py
deleted file mode 100755
index cb7911fd..00000000
--- a/v14/crosperf/crosperf.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""The driver script for running performance benchmarks on ChromeOS."""
-
-import atexit
-import optparse
-import os
-import sys
-from experiment_runner import ExperimentRunner
-from experiment_runner import MockExperimentRunner
-from experiment_factory import ExperimentFactory
-from experiment_file import ExperimentFile
-from help import Help
-from settings_factory import GlobalSettings
-from utils import logger
-
-import test_flag
-
-
-class MyIndentedHelpFormatter(optparse.IndentedHelpFormatter):
-  def format_description(self, description):
-    return description
-
-
-def SetupParserOptions(parser):
-  """Add all options to the parser."""
-  parser.add_option("--dry_run",
-                    dest="dry_run",
-                    help=("Parse the experiment file and "
-                          "show what will be done"),
-                    action="store_true",
-                    default=False)
-  # Allow each of the global fields to be overridden by passing in
-  # options. Add each global field as an option.
-  option_settings = GlobalSettings("")
-  for field_name in option_settings.fields:
-    field = option_settings.fields[field_name]
-    parser.add_option("--%s" % field.name,
-                      dest=field.name,
-                      help=field.description,
-                      action="store")
-
-
-def ConvertOptionsToSettings(options):
-  """Convert options passed in into global settings."""
-  option_settings = GlobalSettings("option_settings")
-  for option_name in options.__dict__:
-    if (options.__dict__[option_name] is not None and
-        option_name in option_settings.fields):
-      option_settings.SetField(option_name, options.__dict__[option_name])
-  return option_settings
-
-
-def Cleanup(experiment):
-  """Handler function which is registered to the atexit handler."""
-  experiment.Cleanup()
-
-
-def Main(argv):
-  parser = optparse.OptionParser(usage=Help().GetUsage(),
-                                 description=Help().GetHelp(),
-                                 formatter=MyIndentedHelpFormatter(),
-                                 version="%prog 0.1")
-
-  parser.add_option("-l", "--log_dir",
-                    dest="log_dir",
-                    default="",
-                    help="The log_dir, default is under <crosperf_logs>/logs")
-
-  SetupParserOptions(parser)
-  options, args = parser.parse_args(argv)
-
-  # Convert the relevant options that are passed in into a settings
-  # object which will override settings in the experiment file.
-  option_settings = ConvertOptionsToSettings(options)
-  log_dir = os.path.abspath(os.path.expanduser(options.log_dir))
-  logger.GetLogger(log_dir)
-
-  if len(args) == 2:
-    experiment_filename = args[1]
-  else:
-    parser.error("Invalid number arguments.")
-
-  working_directory = os.getcwd()
-  if options.dry_run:
-    test_flag.SetTestMode(True)
-
-  experiment_file = ExperimentFile(open(experiment_filename, "rb"),
-                                   option_settings)
-  if not experiment_file.GetGlobalSettings().GetField("name"):
-    experiment_name = os.path.basename(experiment_filename)
-    experiment_file.GetGlobalSettings().SetField("name", experiment_name)
-  experiment = ExperimentFactory().GetExperiment(experiment_file,
-                                                 working_directory,
-                                                 log_dir)
-
-  atexit.register(Cleanup, experiment)
-
-  if options.dry_run:
-    runner = MockExperimentRunner(experiment)
-  else:
-    runner = ExperimentRunner(experiment)
-  runner.Run()
-
-if __name__ == "__main__":
-  Main(sys.argv)
diff --git a/v14/crosperf/crosperf_test.py b/v14/crosperf/crosperf_test.py
deleted file mode 100755
index 0c50e7b5..00000000
--- a/v14/crosperf/crosperf_test.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import os
-import tempfile
-import unittest
-import crosperf
-from utils.file_utils import FileUtils
-
-
-EXPERIMENT_FILE_1 = """
-  board: x86-alex
-  remote: chromeos-alex3
-
-  benchmark: PageCycler {
-    iterations: 3
-  }
-
-  image1 {
-    chromeos_image: /usr/local/google/cros_image1.bin
-  }
-
-  image2 {
-    chromeos_image: /usr/local/google/cros_image2.bin
-  }
-  """
-
-
-class CrosPerfTest(unittest.TestCase):
-  def testDryRun(self):
-    filehandle, filename = tempfile.mkstemp()
-    os.write(filehandle, EXPERIMENT_FILE_1)
-    crosperf.Main(["", filename, "--dry_run"])
-    os.remove(filename)
-
-
-if __name__ == "__main__":
-  FileUtils.Configure(True)
-  unittest.main()
diff --git a/v14/crosperf/default_remotes b/v14/crosperf/default_remotes
deleted file mode 100644
index 5efaebcd..00000000
--- a/v14/crosperf/default_remotes
+++ /dev/null
@@ -1,5 +0,0 @@
-x86-zgb  : chromeos1-rack3-host4.cros chromeos1-rack3-host5.cros chromeos1-rack3-host6.cros
-x86-alex : chromeos2-row1-rack4-host7.cros chromeos2-row1-rack4-host8.cros chromeos2-row1-rack4-host9.cros
-lumpy    : chromeos2-row2-rack4-host10.cros chromeos2-row2-rack4-host11.cros chromeos2-row2-rack4-host12.cros
-stumpy   : chromeos2-row3-rack7-host1.cros chromeos2-row3-rack7-host2.cros chromeos2-row3-rack7-host3.cros
-
diff --git a/v14/crosperf/experiment.py b/v14/crosperf/experiment.py
deleted file mode 100644
index 2a4590c4..00000000
--- a/v14/crosperf/experiment.py
+++ /dev/null
@@ -1,127 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""The experiment setting module."""
-
-import os
-import time
-
-from utils import logger
-
-from benchmark_run import BenchmarkRun
-from machine_manager import MachineManager
-from machine_manager import MockMachineManager
-import test_flag
-
-
-class Experiment(object):
-  """Class representing an Experiment to be run."""
-
-  def __init__(self, name, remote, working_directory,
-               chromeos_root, cache_conditions, labels, benchmarks,
-               experiment_file, email_to, acquire_timeout, log_dir,
-               share_users):
-    self.name = name
-    self.working_directory = working_directory
-    self.remote = remote
-    self.chromeos_root = chromeos_root
-    self.cache_conditions = cache_conditions
-    self.experiment_file = experiment_file
-    self.email_to = email_to
-    self.results_directory = os.path.join(self.working_directory,
-                                          self.name + "_results")
-    self.log_dir = log_dir
-    self.labels = labels
-    self.benchmarks = benchmarks
-    self.num_complete = 0
-    self.num_run_complete = 0
-    self.share_users = share_users
-
-    # We need one chromeos_root to run the benchmarks in, but it doesn't
-    # matter where it is, unless the ABIs are different.
-    if not chromeos_root:
-      for label in self.labels:
-        if label.chromeos_root:
-          chromeos_root = label.chromeos_root
-    if not chromeos_root:
-      raise Exception("No chromeos_root given and could not determine one from "
-                      "the image path.")
-
-    if test_flag.GetTestMode():
-      self.machine_manager = MockMachineManager(chromeos_root, acquire_timeout)
-    else:
-      self.machine_manager = MachineManager(chromeos_root, acquire_timeout)
-    self.l = logger.GetLogger(log_dir)
-
-    for machine in remote:
-      self.machine_manager.AddMachine(machine)
-    for label in labels:
-      self.machine_manager.ComputeCommonCheckSum(label)
-      self.machine_manager.ComputeCommonCheckSumString(label)
-
-    self.start_time = None
-    self.benchmark_runs = self._GenerateBenchmarkRuns()
-
-  def _GenerateBenchmarkRuns(self):
-    """Generate benchmark runs from labels and benchmark defintions."""
-    benchmark_runs = []
-    for label in self.labels:
-      for benchmark in self.benchmarks:
-        for iteration in range(1, benchmark.iterations + 1):
-
-          benchmark_run_name = "%s: %s (%s)" % (label.name, benchmark.name,
-                                                iteration)
-          full_name = "%s_%s_%s" % (label.name, benchmark.name, iteration)
-          logger_to_use = logger.Logger(self.log_dir,
-                                        "run.%s" % (full_name),
-                                        True)
-          benchmark_run = BenchmarkRun(benchmark_run_name,
-                                       benchmark,
-                                       label,
-                                       iteration,
-                                       self.cache_conditions,
-                                       self.machine_manager,
-                                       logger_to_use,
-                                       self.share_users)
-
-          benchmark_runs.append(benchmark_run)
-    return benchmark_runs
-
-  def Build(self):
-    pass
-
-  def Terminate(self):
-    for t in self.benchmark_runs:
-      if t.isAlive():
-        self.l.LogError("Terminating run: '%s'." % t.name)
-        t.Terminate()
-
-  def IsComplete(self):
-    if self.active_threads:
-      for t in self.active_threads:
-        if t.isAlive():
-          t.join(0)
-        if not t.isAlive():
-          self.num_complete += 1
-          if not t.cache_hit:
-            self.num_run_complete += 1
-          self.active_threads.remove(t)
-      return False
-    return True
-
-  def Run(self):
-    self.start_time = time.time()
-    self.active_threads = []
-    for benchmark_run in self.benchmark_runs:
-      # Set threads to daemon so program exits when ctrl-c is pressed.
-      benchmark_run.daemon = True
-      benchmark_run.start()
-      self.active_threads.append(benchmark_run)
-
-  def SetCacheConditions(self, cache_conditions):
-    for benchmark_run in self.benchmark_runs:
-      benchmark_run.SetCacheConditions(cache_conditions)
-
-  def Cleanup(self):
-    self.machine_manager.Cleanup()
diff --git a/v14/crosperf/experiment_factory.py b/v14/crosperf/experiment_factory.py
deleted file mode 100644
index 3c92ee3e..00000000
--- a/v14/crosperf/experiment_factory.py
+++ /dev/null
@@ -1,135 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-"""A module to generate experments."""
-
-import os
-import socket
-
-from benchmark import Benchmark
-import config
-from experiment import Experiment
-from label import Label
-from label import MockLabel
-from results_cache import CacheConditions
-import test_flag
-
-
-class ExperimentFactory(object):
-  """Factory class for building an Experiment, given an ExperimentFile as input.
-
-  This factory is currently hardcoded to produce an experiment for running
-  ChromeOS benchmarks, but the idea is that in the future, other types
-  of experiments could be produced.
-  """
-
-  def GetExperiment(self, experiment_file, working_directory, log_dir):
-    """Construct an experiment from an experiment file."""
-    global_settings = experiment_file.GetGlobalSettings()
-    experiment_name = global_settings.GetField("name")
-    remote = global_settings.GetField("remote")
-    chromeos_root = global_settings.GetField("chromeos_root")
-    rm_chroot_tmp = global_settings.GetField("rm_chroot_tmp")
-    key_results_only = global_settings.GetField("key_results_only")
-    acquire_timeout= global_settings.GetField("acquire_timeout")
-    cache_dir = global_settings.GetField("cache_dir")
-    config.AddConfig("no_email", global_settings.GetField("no_email"))
-    share_users = global_settings.GetField("share_users")
-
-    # Default cache hit conditions. The image checksum in the cache and the
-    # computed checksum of the image must match. Also a cache file must exist.
-    cache_conditions = [CacheConditions.CACHE_FILE_EXISTS,
-                        CacheConditions.CHECKSUMS_MATCH]
-    if global_settings.GetField("rerun_if_failed"):
-      cache_conditions.append(CacheConditions.RUN_SUCCEEDED)
-    if global_settings.GetField("rerun"):
-      cache_conditions.append(CacheConditions.FALSE)
-    if global_settings.GetField("same_machine"):
-      cache_conditions.append(CacheConditions.SAME_MACHINE_MATCH)
-    if global_settings.GetField("same_specs"):
-      cache_conditions.append(CacheConditions.MACHINES_MATCH)
-
-    # Construct benchmarks.
-    benchmarks = []
-    all_benchmark_settings = experiment_file.GetSettings("benchmark")
-    for benchmark_settings in all_benchmark_settings:
-      benchmark_name = benchmark_settings.name
-      autotest_name = benchmark_settings.GetField("autotest_name")
-      if not autotest_name:
-        autotest_name = benchmark_name
-      autotest_args = benchmark_settings.GetField("autotest_args")
-      iterations = benchmark_settings.GetField("iterations")
-      outlier_range = benchmark_settings.GetField("outlier_range")
-      perf_args = benchmark_settings.GetField("perf_args")
-      rm_chroot_tmp = benchmark_settings.GetField("rm_chroot_tmp")
-      key_results_only = benchmark_settings.GetField("key_results_only")
-
-      benchmark = Benchmark(benchmark_name, autotest_name, autotest_args,
-                            iterations, outlier_range,
-                            key_results_only, rm_chroot_tmp,
-                            perf_args)
-      benchmarks.append(benchmark)
-
-    # Construct labels.
-    labels = []
-    all_label_settings = experiment_file.GetSettings("label")
-    all_remote = list(remote)
-    for label_settings in all_label_settings:
-      label_name = label_settings.name
-      image = label_settings.GetField("chromeos_image")
-      chromeos_root = label_settings.GetField("chromeos_root")
-      board = label_settings.GetField("board")
-      my_remote = label_settings.GetField("remote")
-      image_md5sum = label_settings.GetField("md5sum")
-      cache_dir = label_settings.GetField("cache_dir")
-    # TODO(yunlian): We should consolidate code in machine_manager.py
-    # to derermine whether we are running from within google or not
-      if ("corp.google.com" in socket.gethostname() and
-          (not my_remote
-           or my_remote == remote
-           and global_settings.GetField("board") != board)):
-        my_remote = self.GetDefaultRemotes(board)
-      if global_settings.GetField("same_machine") and len(my_remote) > 1:
-        raise Exception("Only one remote is allowed when same_machine "
-                        "is turned on")
-      all_remote += my_remote
-      image_args = label_settings.GetField("image_args")
-      if test_flag.GetTestMode():
-        label = MockLabel(label_name, image, chromeos_root, board, my_remote,
-                          image_args, image_md5sum, cache_dir)
-      else:
-        label = Label(label_name, image, chromeos_root, board, my_remote,
-                      image_args, image_md5sum, cache_dir)
-      labels.append(label)
-
-    email = global_settings.GetField("email")
-    all_remote = list(set(all_remote))
-    experiment = Experiment(experiment_name, all_remote,
-                            working_directory, chromeos_root,
-                            cache_conditions, labels, benchmarks,
-                            experiment_file.Canonicalize(),
-                            email, acquire_timeout, log_dir, share_users)
-
-    return experiment
-
-  def GetDefaultRemotes(self, board):
-    default_remotes_file = os.path.join(os.path.dirname(__file__),
-                                        "default_remotes")
-    try:
-      with open(default_remotes_file) as f:
-        for line in f:
-          key, v = line.split(":")
-          if key.strip() == board:
-            remotes = v.strip().split(" ")
-            if remotes:
-              return remotes
-            else:
-              raise Exception("There is not remote for {0}".format(board))
-    except IOError:
-      raise Exception("IOError while reading file {0}"
-                      .format(default_remotes_file))
-    else:
-      raise Exception("There is not remote for {0}".format(board))
-
-
-
diff --git a/v14/crosperf/experiment_factory_unittest.py b/v14/crosperf/experiment_factory_unittest.py
deleted file mode 100755
index 6cee6b74..00000000
--- a/v14/crosperf/experiment_factory_unittest.py
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import StringIO
-import unittest
-
-from utils.file_utils import FileUtils
-
-from experiment_factory import ExperimentFactory
-from experiment_file import ExperimentFile
-import test_flag
-
-EXPERIMENT_FILE_1 = """
-  board: x86-alex
-  remote: chromeos-alex3
-
-  benchmark: PageCycler {
-    iterations: 3
-  }
-
-  image1 {
-    chromeos_image: /usr/local/google/cros_image1.bin
-  }
-
-  image2 {
-    chromeos_image: /usr/local/google/cros_image2.bin
-  }
-  """
-
-
-class ExperimentFactoryTest(unittest.TestCase):
-  def testLoadExperimentFile1(self):
-    experiment_file = ExperimentFile(StringIO.StringIO(EXPERIMENT_FILE_1))
-    experiment = ExperimentFactory().GetExperiment(experiment_file, 
-                                                   working_directory="",
-                                                   log_dir="")
-    self.assertEqual(experiment.remote, ["chromeos-alex3"])
-
-    self.assertEqual(len(experiment.benchmarks), 1)
-    self.assertEqual(experiment.benchmarks[0].name, "PageCycler")
-    self.assertEqual(experiment.benchmarks[0].autotest_name, "PageCycler")
-    self.assertEqual(experiment.benchmarks[0].iterations, 3)
-
-    self.assertEqual(len(experiment.labels), 2)
-    self.assertEqual(experiment.labels[0].chromeos_image,
-                     "/usr/local/google/cros_image1.bin")
-    self.assertEqual(experiment.labels[0].board,
-                     "x86-alex")
-
-
-if __name__ == "__main__":
-  FileUtils.Configure(True)
-  test_flag.SetTestMode(True)
-  unittest.main()
diff --git a/v14/crosperf/experiment_file.py b/v14/crosperf/experiment_file.py
deleted file mode 100644
index fc0f16ab..00000000
--- a/v14/crosperf/experiment_file.py
+++ /dev/null
@@ -1,185 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2011 The Chromium OS 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 os.path
-import re
-from settings import Settings
-from settings_factory import SettingsFactory
-
-
-class ExperimentFile(object):
-  """Class for parsing the experiment file format.
-
-  The grammar for this format is:
-
-  experiment = { _FIELD_VALUE_RE | settings }
-  settings = _OPEN_SETTINGS_RE
-             { _FIELD_VALUE_RE }
-             _CLOSE_SETTINGS_RE
-
-  Where the regexes are terminals defined below. This results in an format
-  which looks something like:
-
-  field_name: value
-  settings_type: settings_name {
-    field_name: value
-    field_name: value
-  }
-  """
-
-  # Field regex, e.g. "iterations: 3"
-  _FIELD_VALUE_RE = re.compile("(\+)?\s*(\w+?)(?:\.(\S+))?\s*:\s*(.*)")
-  # Open settings regex, e.g. "label {"
-  _OPEN_SETTINGS_RE = re.compile("(?:(\w+):)?\s*(\w+)\s*{")
-  # Close settings regex.
-  _CLOSE_SETTINGS_RE = re.compile("}")
-
-  def __init__(self, experiment_file, overrides=None):
-    """Construct object from file-like experiment_file.
-
-    Args:
-      experiment_file: file-like object with text description of experiment.
-      overrides: A settings object that will override fields in other settings.
-
-    Raises:
-      Exception: if invalid build type or description is invalid.
-    """
-    self.all_settings = []
-    self.global_settings = SettingsFactory().GetSettings("global", "global")
-    self.all_settings.append(self.global_settings)
-
-    self._Parse(experiment_file)
-
-    for settings in self.all_settings:
-      settings.Inherit()
-      settings.Validate()
-      if overrides:
-        settings.Override(overrides)
-
-  def GetSettings(self, settings_type):
-    """Return nested fields from the experiment file."""
-    res = []
-    for settings in self.all_settings:
-      if settings.settings_type == settings_type:
-        res.append(settings)
-    return res
-
-  def GetGlobalSettings(self):
-    """Return the global fields from the experiment file."""
-    return self.global_settings
-
-  def _ParseField(self, reader):
-    """Parse a key/value field."""
-    line = reader.CurrentLine().strip()
-    match = ExperimentFile._FIELD_VALUE_RE.match(line)
-    append, name, _, text_value = match.groups()
-    return (name, text_value, append)
-
-  def _ParseSettings(self, reader):
-    """Parse a settings block."""
-    line = reader.CurrentLine().strip()
-    match = ExperimentFile._OPEN_SETTINGS_RE.match(line)
-    settings_type = match.group(1)
-    if settings_type is None:
-      settings_type = ""
-    settings_name = match.group(2)
-    settings = SettingsFactory().GetSettings(settings_name, settings_type)
-    settings.SetParentSettings(self.global_settings)
-
-    while reader.NextLine():
-      line = reader.CurrentLine().strip()
-
-      if not line:
-        continue
-      elif ExperimentFile._FIELD_VALUE_RE.match(line):
-        field = self._ParseField(reader)
-        settings.SetField(field[0], field[1], field[2])
-      elif ExperimentFile._CLOSE_SETTINGS_RE.match(line):
-        return settings
-
-    raise Exception("Unexpected EOF while parsing settings block.")
-
-  def _Parse(self, experiment_file):
-    """Parse experiment file and create settings."""
-    reader = ExperimentFileReader(experiment_file)
-    settings_names = {}
-    try:
-      while reader.NextLine():
-        line = reader.CurrentLine().strip()
-
-        if not line:
-          continue
-        elif ExperimentFile._OPEN_SETTINGS_RE.match(line):
-          new_settings = self._ParseSettings(reader)
-          if new_settings.name in settings_names:
-            raise Exception("Duplicate settings name: '%s'." %
-                            new_settings.name)
-          settings_names[new_settings.name] = True
-          self.all_settings.append(new_settings)
-        elif ExperimentFile._FIELD_VALUE_RE.match(line):
-          field = self._ParseField(reader)
-          self.global_settings.SetField(field[0], field[1], field[2])
-        else:
-          raise Exception("Unexpected line.")
-    except Exception, err:
-      raise Exception("Line %d: %s\n==> %s" % (reader.LineNo(), str(err),
-                                               reader.CurrentLine(False)))
-
-  def Canonicalize(self):
-    """Convert parsed experiment file back into an experiment file."""
-    res = ""
-    for field_name in self.global_settings.fields:
-      field = self.global_settings.fields[field_name]
-      if field.assigned:
-        res += "%s: %s\n" % (field.name, field.GetString())
-    res += "\n"
-
-    for settings in self.all_settings:
-      if settings.settings_type != "global":
-        res += "%s: %s {\n" % (settings.settings_type, settings.name)
-        for field_name in settings.fields:
-          field = settings.fields[field_name]
-          if field.assigned:
-            res += "\t%s: %s\n" % (field.name, field.GetString())
-            if field.name == "chromeos_image":
-              real_file = (os.path.realpath
-                           (os.path.expanduser(field.GetString())))
-              if real_file != field.GetString():
-                res += "\t#actual_image: %s\n" % real_file
-        res += "}\n\n"
-
-    return res
-
-
-class ExperimentFileReader(object):
-  """Handle reading lines from an experiment file."""
-
-  def __init__(self, file_object):
-    self.file_object = file_object
-    self.current_line = None
-    self.current_line_no = 0
-
-  def CurrentLine(self, strip_comment=True):
-    """Return the next line from the file, without advancing the iterator."""
-    if strip_comment:
-      return self._StripComment(self.current_line)
-    return self.current_line
-
-  def NextLine(self, strip_comment=True):
-    """Advance the iterator and return the next line of the file."""
-    self.current_line_no += 1
-    self.current_line = self.file_object.readline()
-    return self.CurrentLine(strip_comment)
-
-  def _StripComment(self, line):
-    """Strip comments starting with # from a line."""
-    if "#" in line:
-      line = line[:line.find("#")] + line[-1]
-    return line
-
-  def LineNo(self):
-    """Return the current line number."""
-    return self.current_line_no
diff --git a/v14/crosperf/experiment_file_unittest.py b/v14/crosperf/experiment_file_unittest.py
deleted file mode 100755
index d08c7eb5..00000000
--- a/v14/crosperf/experiment_file_unittest.py
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2011 The Chromium OS 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 StringIO
-import unittest
-from experiment_file import ExperimentFile
-
-EXPERIMENT_FILE_1 = """
-  board: x86-alex
-  remote: chromeos-alex3
-  perf_args: record -a -e cycles
-  benchmark: PageCycler {
-    iterations: 3
-  }
-
-  image1 {
-    chromeos_image: /usr/local/google/cros_image1.bin
-  }
-
-  image2 {
-    board: lumpy
-    remote: chromeos-lumpy1
-    chromeos_image: /usr/local/google/cros_image2.bin
-  }
-  """
-
-EXPERIMENT_FILE_2 = """
-  board: x86-alex
-  remote: chromeos-alex3
-  iterations: 3
-
-  benchmark: PageCycler {
-  }
-
-  benchmark: AndroidBench {
-    iterations: 2
-  }
-
-  image1 {
-    chromeos_image:/usr/local/google/cros_image1.bin
-  }
-
-  image2 {
-    chromeos_image: /usr/local/google/cros_image2.bin
-  }
-  """
-
-EXPERIMENT_FILE_3 = """
-  board: x86-alex
-  remote: chromeos-alex3
-  iterations: 3
-
-  benchmark: PageCycler {
-  }
-
-  image1 {
-    chromeos_image:/usr/local/google/cros_image1.bin
-  }
-
-  image1 {
-    chromeos_image: /usr/local/google/cros_image2.bin
-  }
-  """
-
-
-class ExperimentFileTest(unittest.TestCase):
-  def testLoadExperimentFile1(self):
-    input_file = StringIO.StringIO(EXPERIMENT_FILE_1)
-    experiment_file = ExperimentFile(input_file)
-    global_settings = experiment_file.GetGlobalSettings()
-    self.assertEqual(global_settings.GetField("remote"), ["chromeos-alex3"])
-    self.assertEqual(global_settings.GetField("perf_args"),
-                     "record -a -e cycles")
-    benchmark_settings = experiment_file.GetSettings("benchmark")
-    self.assertEqual(len(benchmark_settings), 1)
-    self.assertEqual(benchmark_settings[0].name, "PageCycler")
-    self.assertEqual(benchmark_settings[0].GetField("iterations"), 3)
-
-    label_settings = experiment_file.GetSettings("label")
-    self.assertEqual(len(label_settings), 2)
-    self.assertEqual(label_settings[0].name, "image1")
-    self.assertEqual(label_settings[0].GetField("board"), "x86-alex")
-    self.assertEqual(label_settings[0].GetField("chromeos_image"),
-                     "/usr/local/google/cros_image1.bin")
-    self.assertEqual(label_settings[1].GetField("remote"), ["chromeos-lumpy1"])
-    self.assertEqual(label_settings[0].GetField("remote"), ["chromeos-alex3"])
-
-  def testOverrideSetting(self):
-    input_file = StringIO.StringIO(EXPERIMENT_FILE_2)
-    experiment_file = ExperimentFile(input_file)
-    global_settings = experiment_file.GetGlobalSettings()
-    self.assertEqual(global_settings.GetField("remote"), ["chromeos-alex3"])
-
-    benchmark_settings = experiment_file.GetSettings("benchmark")
-    self.assertEqual(len(benchmark_settings), 2)
-    self.assertEqual(benchmark_settings[0].name, "PageCycler")
-    self.assertEqual(benchmark_settings[0].GetField("iterations"), 3)
-    self.assertEqual(benchmark_settings[1].name, "AndroidBench")
-    self.assertEqual(benchmark_settings[1].GetField("iterations"), 2)
-
-  def testDuplicateLabel(self):
-    input_file = StringIO.StringIO(EXPERIMENT_FILE_3)
-    self.assertRaises(Exception, ExperimentFile, input_file)
-
-
-if __name__ == "__main__":
-  unittest.main()
diff --git a/v14/crosperf/experiment_files/README b/v14/crosperf/experiment_files/README
deleted file mode 100644
index 5c0e3d41..00000000
--- a/v14/crosperf/experiment_files/README
+++ /dev/null
@@ -1,26 +0,0 @@
-To use these experiment files, add board, remote and images and run crosperf
-on them.
-
-Further information about crosperf:
-https://sites.google.com/a/google.com/compiler-chromeos-workflows/crosperf
-
-The final experiment file should look something like the following:
-
-board: <board>
-remote: <ip address or machine name>
-
-# Add images you want to test:
-label: myimage {
-  chromeos_image: <path to image>
-}
-
-# Paste experiment benchmarks here. Example, I pasted aes_perf here.
-
-# This experiment just runs a short autotest which measures the performance of
-# aes encryption. In addition, it profiles
-
-profile_type: record
-profile_counters: instructions cycles
-
-benchmark: platform_AesThroughput {
-}
diff --git a/v14/crosperf/experiment_files/aes_perf b/v14/crosperf/experiment_files/aes_perf
deleted file mode 100644
index 0c54ccbd..00000000
--- a/v14/crosperf/experiment_files/aes_perf
+++ /dev/null
@@ -1,7 +0,0 @@
-# This experiment just runs a short autotest which measures the performance of
-# aes encryption. In addition, it profiles
-
-profile_args: record -e cycles -e instructions
-
-benchmark: platform_AesThroughput {
-}
diff --git a/v14/crosperf/experiment_files/bloat_perf b/v14/crosperf/experiment_files/bloat_perf
deleted file mode 100644
index f8258ee1..00000000
--- a/v14/crosperf/experiment_files/bloat_perf
+++ /dev/null
@@ -1,6 +0,0 @@
-perf_args: record -e cycles
-
-benchmark: bloat {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=1 perf.PageCyclerTest.testBloatFile'
-}
diff --git a/v14/crosperf/experiment_files/morejs_perf b/v14/crosperf/experiment_files/morejs_perf
deleted file mode 100644
index a02f15f5..00000000
--- a/v14/crosperf/experiment_files/morejs_perf
+++ /dev/null
@@ -1,6 +0,0 @@
-perf_args: record -e cycles
-
-benchmark: morejs {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=1 perf.PageCyclerTest.testMoreJSFile'
-}
diff --git a/v14/crosperf/experiment_files/page_cycler b/v14/crosperf/experiment_files/page_cycler
deleted file mode 100644
index ada9ed67..00000000
--- a/v14/crosperf/experiment_files/page_cycler
+++ /dev/null
@@ -1,6 +0,0 @@
-# This experiment runs page cycler tests.
-
-benchmark: AllPageCyclers {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='perf.PageCyclerTest'
-}
diff --git a/v14/crosperf/experiment_files/page_cycler_perf b/v14/crosperf/experiment_files/page_cycler_perf
deleted file mode 100644
index 7f5e7118..00000000
--- a/v14/crosperf/experiment_files/page_cycler_perf
+++ /dev/null
@@ -1,43 +0,0 @@
-# This experiment profiles all page cyclers.
-
-perf_args: record -e cycles
-
-benchmark: morejs {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testMoreJSFile'
-}
-
-benchmark: alexa {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testAlexaFile'
-}
-
-benchmark: bloat {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testBloatFile'
-}
-
-benchmark: dhtml {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testDHTMLFile'
-}
-
-benchmark: intl1 {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testIntl1File'
-}
-
-benchmark: intl2 {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testIntl2File'
-}
-
-benchmark: moz {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testMozFile'
-}
-
-benchmark: moz2 {
-	autotest_name: desktopui_PyAutoPerfTests
-	autotest_args: --args='--iterations=10 perf.PageCyclerTest.testMoz2File'
-}
diff --git a/v14/crosperf/experiment_files/toolchain b/v14/crosperf/experiment_files/toolchain
deleted file mode 100644
index 9156998b..00000000
--- a/v14/crosperf/experiment_files/toolchain
+++ /dev/null
@@ -1,16 +0,0 @@
-# Use this experiment whenever the toolchain is upgraded.
-
-benchmark: bvt {
-  autotest_name: suite:bvt
-}
-
-benchmark: suite_Smoke {
-  autotest_name: suite:smoke
-}
-
-benchmark: PyAutoPerfTests {
-}
-
-benchmark: BootPerfServer {
-  autotest_name: ^server/site_tests/platform_BootPerfServer/control$
-}
diff --git a/v14/crosperf/experiment_runner.py b/v14/crosperf/experiment_runner.py
deleted file mode 100644
index 9212ba56..00000000
--- a/v14/crosperf/experiment_runner.py
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""The experiment runner module."""
-import getpass
-import os
-import time
-
-from utils import command_executer
-from utils import logger
-from utils.email_sender import EmailSender
-from utils.file_utils import FileUtils
-
-import config
-from experiment_status import ExperimentStatus
-from results_report import HTMLResultsReport
-from results_report import TextResultsReport
-
-
-class ExperimentRunner(object):
-  """ExperimentRunner Class."""
-
-  STATUS_TIME_DELAY = 30
-  THREAD_MONITOR_DELAY = 2
-
-  def __init__(self, experiment):
-    self._experiment = experiment
-    self.l = logger.GetLogger(experiment.log_dir)
-    self._ce = command_executer.GetCommandExecuter(self.l)
-    self._terminated = False
-
-  def _Run(self, experiment):
-    status = ExperimentStatus(experiment)
-    experiment.Run()
-    last_status_time = 0
-    try:
-      while not experiment.IsComplete():
-        if last_status_time + self.STATUS_TIME_DELAY < time.time():
-          last_status_time = time.time()
-          border = "=============================="
-          self.l.LogOutput(border)
-          self.l.LogOutput(status.GetProgressString())
-          self.l.LogOutput(status.GetStatusString())
-          logger.GetLogger().LogOutput(border)
-        time.sleep(self.THREAD_MONITOR_DELAY)
-    except KeyboardInterrupt:
-      self._terminated = True
-      self.l.LogError("Ctrl-c pressed. Cleaning up...")
-      experiment.Terminate()
-
-  def _PrintTable(self, experiment):
-    self.l.LogOutput(TextResultsReport(experiment).GetReport())
-
-  def _Email(self, experiment):
-    # Only email by default if a new run was completed.
-    send_mail = False
-    for benchmark_run in experiment.benchmark_runs:
-      if not benchmark_run.cache_hit:
-        send_mail = True
-        break
-    if (not send_mail and not experiment.email_to
-        or config.GetConfig("no_email")):
-      return
-
-    label_names = []
-    for label in experiment.labels:
-      label_names.append(label.name)
-    subject = "%s: %s" % (experiment.name, " vs. ".join(label_names))
-
-    text_report = TextResultsReport(experiment, True).GetReport()
-    text_report = "<pre style='font-size: 13px'>%s</pre>" % text_report
-    html_report = HTMLResultsReport(experiment).GetReport()
-    attachment = EmailSender.Attachment("report.html", html_report)
-    email_to = [getpass.getuser()] + experiment.email_to
-    EmailSender().SendEmail(email_to,
-                            subject,
-                            text_report,
-                            attachments=[attachment],
-                            msg_type="html")
-
-  def _StoreResults (self, experiment):
-    if self._terminated:
-      return
-    results_directory = experiment.results_directory
-    FileUtils().RmDir(results_directory)
-    FileUtils().MkDirP(results_directory)
-    self.l.LogOutput("Storing experiment file.")
-    experiment_file_path = os.path.join(results_directory,
-                                        "experiment.exp")
-    FileUtils().WriteFile(experiment_file_path, experiment.experiment_file)
-
-    self.l.LogOutput("Storing results report.")
-    results_table_path = os.path.join(results_directory, "results.html")
-    report = HTMLResultsReport(experiment).GetReport()
-    FileUtils().WriteFile(results_table_path, report)
-
-    self.l.LogOutput("Storing results of each benchmark run.")
-    for benchmark_run in experiment.benchmark_runs:
-      if benchmark_run.result:
-        benchmark_run_name = filter(str.isalnum, benchmark_run.name)
-        benchmark_run_path = os.path.join(results_directory,
-                                          benchmark_run_name)
-        benchmark_run.result.CopyResultsTo(benchmark_run_path)
-        benchmark_run.result.CleanUp(benchmark_run.benchmark.rm_chroot_tmp)
-
-  def Run(self):
-    self._Run(self._experiment)
-    self._PrintTable(self._experiment)
-    if not self._terminated:
-      self._StoreResults(self._experiment)
-      self._Email(self._experiment)
-
-
-class MockExperimentRunner(ExperimentRunner):
-  """Mocked ExperimentRunner for testing."""
-
-  def __init__(self, experiment):
-    super(MockExperimentRunner, self).__init__(experiment)
-
-  def _Run(self, experiment):
-    self.l.LogOutput("Would run the following experiment: '%s'." %
-                     experiment.name)
-
-  def _PrintTable(self, experiment):
-    self.l.LogOutput("Would print the experiment table.")
-
-  def _Email(self, experiment):
-    self.l.LogOutput("Would send result email.")
-
-  def _StoreResults(self, experiment):
-    self.l.LogOutput("Would store the results.")
diff --git a/v14/crosperf/experiment_status.py b/v14/crosperf/experiment_status.py
deleted file mode 100644
index 3a270663..00000000
--- a/v14/crosperf/experiment_status.py
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""The class to show the banner."""
-
-import datetime
-import time
-
-
-class ExperimentStatus(object):
-  """The status class."""
-
-  def __init__(self, experiment):
-    self.experiment = experiment
-    self.num_total = len(self.experiment.benchmark_runs)
-    self.completed = 0
-    self.new_job_start_time = time.time()
-
-  def _GetProgressBar(self, num_complete, num_total):
-    ret = "Done: %s%%" % int(100.0 * num_complete / num_total)
-    bar_length = 50
-    done_char = ">"
-    undone_char = " "
-    num_complete_chars = bar_length * num_complete / num_total
-    num_undone_chars = bar_length - num_complete_chars
-    ret += " [%s%s]" % (num_complete_chars * done_char, num_undone_chars *
-                        undone_char)
-    return ret
-
-  def GetProgressString(self):
-    """Get the elapsed_time, ETA."""
-    current_time = time.time()
-    if self.experiment.start_time:
-      elapsed_time = current_time - self.experiment.start_time
-    else:
-      elapsed_time = 0
-    try:
-      if self.completed != self.experiment.num_complete:
-        self.completed = self.experiment.num_complete
-        self.new_job_start_time = current_time
-      time_completed_jobs = (elapsed_time -
-                             (current_time - self.new_job_start_time))
-      eta_seconds = (float(self.num_total - self.experiment.num_complete -1) *
-                     time_completed_jobs / self.experiment.num_run_complete
-                     + (time_completed_jobs / self.experiment.num_run_complete
-                        - (current_time - self.new_job_start_time)))
-
-      eta_seconds = int(eta_seconds)
-      eta = datetime.timedelta(seconds=eta_seconds)
-    except ZeroDivisionError:
-      eta = "Unknown"
-    strings = []
-    strings.append("Current time: %s Elapsed: %s ETA: %s" %
-                   (datetime.datetime.now(),
-                    datetime.timedelta(seconds=int(elapsed_time)),
-                    eta))
-    strings.append(self._GetProgressBar(self.experiment.num_complete,
-                                        self.num_total))
-    return "\n".join(strings)
-
-  def GetStatusString(self):
-    """Get the status string of all the benchmark_runs."""
-    status_bins = {}
-    for benchmark_run in self.experiment.benchmark_runs:
-      if benchmark_run.timeline.GetLastEvent() not in status_bins:
-        status_bins[benchmark_run.timeline.GetLastEvent()] = []
-      status_bins[benchmark_run.timeline.GetLastEvent()].append(benchmark_run)
-
-    status_strings = []
-    for key, val in status_bins.items():
-      status_strings.append("%s: %s" %
-                            (key, self._GetNamesAndIterations(val)))
-    result = "Thread Status:\n%s" % "\n".join(status_strings)
-
-    # Add the machine manager status.
-    result += "\n" + self.experiment.machine_manager.AsString() + "\n"
-
-    return result
-
-  def _GetNamesAndIterations(self, benchmark_runs):
-    strings = []
-    t = time.time()
-    for benchmark_run in benchmark_runs:
-      t_last = benchmark_run.timeline.GetLastEventTime()
-      elapsed = str(datetime.timedelta(seconds=int(t-t_last)))
-      strings.append("'{0}' {1}".format(benchmark_run.name, elapsed))
-    return " %s (%s)" % (len(strings), ", ".join(strings))
diff --git a/v14/crosperf/field.py b/v14/crosperf/field.py
deleted file mode 100644
index b3cdaa23..00000000
--- a/v14/crosperf/field.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-
-class Field(object):
-  """Class representing a Field in an experiment file."""
-
-  def __init__(self, name, required, default, inheritable, description):
-    self.name = name
-    self.required = required
-    self.assigned = False
-    self.default = default
-    self._value = default
-    self.inheritable = inheritable
-    self.description = description
-
-  def Set(self, value, parse=True):
-    if parse:
-      self._value = self._Parse(value)
-    else:
-      self._value = value
-    self.assigned = True
-
-  def Append(self, value):
-    self._value += self._Parse(value)
-    self.assigned = True
-
-  def _Parse(self, value):
-    return value
-
-  def Get(self):
-    return self._value
-
-  def GetString(self):
-    return str(self._value)
-
-
-class TextField(Field):
-  def __init__(self, name, required=False, default="", inheritable=False,
-               description=""):
-    super(TextField, self).__init__(name, required, default, inheritable,
-                                    description)
-
-  def _Parse(self, value):
-    return str(value)
-
-
-class BooleanField(Field):
-  def __init__(self, name, required=False, default=False, inheritable=False,
-               description=""):
-    super(BooleanField, self).__init__(name, required, default, inheritable,
-                                       description)
-
-  def _Parse(self, value):
-    if value.lower() == "true":
-      return True
-    elif value.lower() == "false":
-      return False
-    raise Exception("Invalid value for '%s'. Must be true or false." %
-                    self.name)
-
-
-class IntegerField(Field):
-  def __init__(self, name, required=False, default=0, inheritable=False,
-               description=""):
-    super(IntegerField, self).__init__(name, required, default, inheritable,
-                                       description)
-
-  def _Parse(self, value):
-    return int(value)
-
-
-class FloatField(Field):
-  def __init__(self, name, required=False, default=0, inheritable=False,
-               description=""):
-    super(FloatField, self).__init__(name, required, default, inheritable,
-                                     description)
-
-  def _Parse(self, value):
-    return float(value)
-
-
-class ListField(Field):
-  def __init__(self, name, required=False, default=[], inheritable=False,
-               description=""):
-    super(ListField, self).__init__(name, required, default, inheritable,
-                                    description)
-
-  def _Parse(self, value):
-    return value.split()
-
-  def GetString(self):
-    return " ".join(self._value)
-
-
-class EnumField(Field):
-  def __init__(self, name, options, required=False, default="",
-               inheritable=False, description=""):
-    super(EnumField, self).__init__(name, required, default, inheritable,
-                                    description)
-    self.options = options
-
-  def _Parse(self, value):
-    if value not in self.options:
-      raise Exception("Invalid enum value for field '%s'. Must be one of (%s)"
-                      % (self.name, ", ".join(self.options)))
-    return str(value)
diff --git a/v14/crosperf/help.py b/v14/crosperf/help.py
deleted file mode 100644
index cf74d93e..00000000
--- a/v14/crosperf/help.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import sys
-import textwrap
-from settings_factory import BenchmarkSettings
-from settings_factory import GlobalSettings
-from settings_factory import LabelSettings
-
-
-class Help(object):
-  def GetUsage(self):
-    return """%s [OPTIONS] [ACTION] EXPERIMENT_FILE""" % (sys.argv[0])
-
-  def _WrapLine(self, line):
-    return "\n".join(textwrap.wrap(line, 80))
-
-  def _GetFieldDescriptions(self, fields):
-    res = ""
-    for field_name in fields:
-      field = fields[field_name]
-      res += "Field:\t\t%s\n" % field.name
-      res += self._WrapLine("Description:\t%s" % field.description) + "\n"
-      res += "Type:\t\t%s\n" % type(field).__name__.replace("Field", "")
-      res += "Required:\t%s\n" % field.required
-      if field.default:
-        res += "Default:\t%s\n" % field.default
-      res += "\n"
-    return res
-
-  def GetHelp(self):
-    global_fields = self._GetFieldDescriptions(GlobalSettings("").fields)
-    benchmark_fields = self._GetFieldDescriptions(BenchmarkSettings("").fields)
-    label_fields = self._GetFieldDescriptions(LabelSettings("").fields)
-
-    return """%s is a script for running performance experiments on ChromeOS. It
-allows one to run ChromeOS Autotest benchmarks over several images and compare
-the results to determine whether there is a performance difference.
-
-Comparing several images using %s is referred to as running an
-"experiment". An "experiment file" is a configuration file which holds all the
-information that describes the experiment and how it should be run. An example
-of a simple experiment file is below:
-
---------------------------------- test.exp ---------------------------------
-name: my_experiment
-board: x86-alex
-remote: chromeos-alex5 172.18.122.132
-
-benchmark: PageCycler {
-  iterations: 3
-}
-
-my_first_image {
-  chromeos_image: /usr/local/chromeos-1/chromiumos_image.bin
-}
-
-my_second_image {
-  chromeos_image:  /usr/local/chromeos-2/chromiumos_image.bin
-}
-----------------------------------------------------------------------------
-
-This experiment file names the experiment "my_experiment". It will be run
-on the board x86-alex. Benchmarks will be run using two remote devices,
-one is a device specified by a hostname and the other is a device specified
-by it's IP address. Benchmarks will be run in parallel across these devices.
-There is currently no way to specify which benchmark will run on each device.
-
-We define one "benchmark" that will be run, PageCycler. This benchmark has one
-"field" which specifies how many iterations it will run for.
-
-We specify 2 "labels" or images which will be compared. The PageCycler benchmark
-will be run on each of these images 3 times and a result table will be output
-which compares the two.
-
-The full list of fields that can be specified are as follows:
-=================
-Global Fields
-=================
-%s
-=================
-Benchmark Fields
-=================
-%s
-=================
-Label Fields
-=================
-%s
-
-Note that global fields are overidden by label or benchmark fields, if they can
-be specified in both places. Fields that are specified as arguments override
-fields specified in experiment files.
-
-%s is invoked by passing it a path to an experiment file, as well as an action
-to execute on that experiment file. The possible actions to use are:
-
-run\t\tRun the experiment and cache the results.
-
-table\t\tDisplay cached results of an experiment, without running anything.
-
-email\t\tEmail a summary of the results to the user.
-
-do\t\tThe default action. Executes the following actions: run, table, email.
-""" % (sys.argv[0], sys.argv[0], global_fields,
-       benchmark_fields, label_fields, sys.argv[0])
diff --git a/v14/crosperf/image_checksummer.py b/v14/crosperf/image_checksummer.py
deleted file mode 100644
index dcc1cb02..00000000
--- a/v14/crosperf/image_checksummer.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import os
-import threading
-
-from utils import logger
-from utils.file_utils import FileUtils
-
-
-class ImageChecksummer(object):
-  class PerImageChecksummer(object):
-    def __init__(self, label):
-      self._lock = threading.Lock()
-      self.label = label
-      self._checksum = None
-
-    def Checksum(self):
-      with self._lock:
-        if not self._checksum:
-          logger.GetLogger().LogOutput("Acquiring checksum for '%s'." %
-                                       self.label.name)
-          self._checksum = None
-          if self.label.chromeos_image:
-            if os.path.exists(self.label.chromeos_image):
-              self._checksum = FileUtils().Md5File(self.label.chromeos_image)
-              logger.GetLogger().LogOutput("Computed checksum is "
-                                           ": %s" % self._checksum)
-          if not self._checksum:
-            if self.label.image_md5sum:
-              self._checksum = self.label.image_md5sum
-              logger.GetLogger().LogOutput("Checksum in experiment file is "
-                                           ": %s" % self._checksum)
-            else:
-              raise Exception("Checksum computing error.")
-          logger.GetLogger().LogOutput("Checksum is: %s" % self._checksum)
-        return self._checksum
-
-  _instance = None
-  _lock = threading.Lock()
-  _per_image_checksummers = {}
-
-  def __new__(cls, *args, **kwargs):
-    with cls._lock:
-      if not cls._instance:
-        cls._instance = super(ImageChecksummer, cls).__new__(cls,
-                                                             *args, **kwargs)
-      return cls._instance
-
-  def Checksum(self, label):
-    with self._lock:
-      if label.name not in self._per_image_checksummers:
-        self._per_image_checksummers[label.name] = (ImageChecksummer.
-                                                    PerImageChecksummer(label))
-      checksummer = self._per_image_checksummers[label.name]
-
-    try:
-      return checksummer.Checksum()
-    except Exception, e:
-      logger.GetLogger().LogError("Could not compute checksum of image in label"
-                                  " '%s'."% label.name)
-      raise e
diff --git a/v14/crosperf/label.py b/v14/crosperf/label.py
deleted file mode 100644
index be7a868e..00000000
--- a/v14/crosperf/label.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""The label of benchamrks."""
-
-import os
-from utils.file_utils import FileUtils
-
-
-class Label(object):
-  def __init__(self, name, chromeos_image, chromeos_root, board, remote,
-               image_args, image_md5sum, cache_dir):
-    # Expand ~
-    chromeos_root = os.path.expanduser(chromeos_root)
-    chromeos_image = os.path.expanduser(chromeos_image)
-
-    self.name = name
-    self.chromeos_image = chromeos_image
-    self.board = board
-    self.remote = remote
-    self.image_args = image_args
-    self.image_md5sum = image_md5sum
-    self.cache_dir = cache_dir
-
-    if not chromeos_root:
-      chromeos_root = FileUtils().ChromeOSRootFromImage(chromeos_image)
-      if not chromeos_root:
-        raise Exception("No ChromeOS root given for label '%s' and could not "
-                        "determine one from image path: '%s'." %
-                        (name, chromeos_image))
-    else:
-      chromeos_root = FileUtils().CanonicalizeChromeOSRoot(chromeos_root)
-      if not chromeos_root:
-        raise Exception("Invalid ChromeOS root given for label '%s': '%s'."
-                        % (name, chromeos_root))
-
-    self.chromeos_root = chromeos_root
-
-
-class MockLabel(object):
-  def __init__(self, name, chromeos_image, chromeos_root, board, remote,
-               image_args, image_md5sum, cache_dir):
-    self.name = name
-    self.chromeos_image = chromeos_image
-    self.board = board
-    self.remote = remote
-    self.cache_dir = cache_dir
-    if not chromeos_root:
-      self.chromeos_root = "/tmp/chromeos_root"
-    else:
-      self.chromeos_root = chromeos_root
-    self.image_args = image_args
-    self.image_md5sum = image_md5sum
diff --git a/v14/crosperf/machine_manager.py b/v14/crosperf/machine_manager.py
deleted file mode 100644
index 29a4df7a..00000000
--- a/v14/crosperf/machine_manager.py
+++ /dev/null
@@ -1,419 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-import hashlib
-import image_chromeos
-import lock_machine
-import math
-import os.path
-import re
-import sys
-import threading
-import time
-
-from utils import command_executer
-from utils import logger
-from utils.file_utils import FileUtils
-
-from image_checksummer import ImageChecksummer
-
-CHECKSUM_FILE = "/usr/local/osimage_checksum_file"
-
-
-class CrosMachine(object):
-  def __init__(self, name, chromeos_root):
-    self.name = name
-    self.image = None
-    self.checksum = None
-    self.locked = False
-    self.released_time = time.time()
-    self.autotest_run = None
-    self.chromeos_root = chromeos_root
-    self._GetMemoryInfo()
-    self._GetCPUInfo()
-    self._ComputeMachineChecksumString()
-    self._GetMachineID()
-    self.machine_checksum = self._GetMD5Checksum(self.checksum_string)
-    self.machine_id_checksum = self._GetMD5Checksum(self.machine_id)
-
-  def _ParseMemoryInfo(self):
-    line = self.meminfo.splitlines()[0]
-    usable_kbytes = int(line.split()[1])
-    # This code is from src/third_party/autotest/files/client/bin/base_utils.py
-    # usable_kbytes is system's usable DRAM in kbytes,
-    #   as reported by memtotal() from device /proc/meminfo memtotal
-    #   after Linux deducts 1.5% to 9.5% for system table overhead
-    # Undo the unknown actual deduction by rounding up
-    #   to next small multiple of a big power-of-two
-    #   eg  12GB - 5.1% gets rounded back up to 12GB
-    mindeduct = 0.005  # 0.5 percent
-    maxdeduct = 0.095  # 9.5 percent
-    # deduction range 1.5% .. 9.5% supports physical mem sizes
-    #    6GB .. 12GB in steps of .5GB
-    #   12GB .. 24GB in steps of 1 GB
-    #   24GB .. 48GB in steps of 2 GB ...
-    # Finer granularity in physical mem sizes would require
-    #   tighter spread between min and max possible deductions
-
-    # increase mem size by at least min deduction, without rounding
-    min_kbytes = int(usable_kbytes / (1.0 - mindeduct))
-    # increase mem size further by 2**n rounding, by 0..roundKb or more
-    round_kbytes = int(usable_kbytes / (1.0 - maxdeduct)) - min_kbytes
-    # find least binary roundup 2**n that covers worst-cast roundKb
-    mod2n = 1 << int(math.ceil(math.log(round_kbytes, 2)))
-    # have round_kbytes <= mod2n < round_kbytes*2
-    # round min_kbytes up to next multiple of mod2n
-    phys_kbytes = min_kbytes + mod2n - 1
-    phys_kbytes -= phys_kbytes % mod2n  # clear low bits
-    self.phys_kbytes = phys_kbytes
-
-  def _GetMemoryInfo(self):
-    #TODO yunlian: when the machine in rebooting, it will not return
-    #meminfo, the assert does not catch it either
-    ce = command_executer.GetCommandExecuter()
-    command = "cat /proc/meminfo"
-    ret, self.meminfo, _ = ce.CrosRunCommand(
-        command, return_output=True,
-        machine=self.name, username="root", chromeos_root=self.chromeos_root)
-    assert ret == 0, "Could not get meminfo from machine: %s" % self.name
-    if ret == 0:
-      self._ParseMemoryInfo()
-
-  #cpuinfo format is different across architecture
-  #need to find a better way to parse it.
-  def _ParseCPUInfo(self,cpuinfo):
-    return 0
-
-  def _GetCPUInfo(self):
-    ce = command_executer.GetCommandExecuter()
-    command = "cat /proc/cpuinfo"
-    ret, self.cpuinfo, _ = ce.CrosRunCommand(
-        command, return_output=True,
-        machine=self.name, username="root", chromeos_root=self.chromeos_root)
-    assert ret == 0, "Could not get cpuinfo from machine: %s" % self.name
-    if ret == 0:
-      self._ParseCPUInfo(self.cpuinfo)
-
-  def _ComputeMachineChecksumString(self):
-    self.checksum_string = ""
-    exclude_lines_list = ["MHz", "BogoMIPS", "bogomips"]
-    for line in self.cpuinfo.splitlines():
-      if not any([e in line for e in exclude_lines_list]):
-        self.checksum_string += line
-    self.checksum_string += " " + str(self.phys_kbytes)
-
-  def _GetMD5Checksum(self, ss):
-    if ss:
-      return hashlib.md5(ss).hexdigest()
-    else:
-      return ""
-
-  def _GetMachineID(self):
-    ce = command_executer.GetCommandExecuter()
-    command = "dump_vpd_log --full --stdout"
-    ret, if_out, _ = ce.CrosRunCommand(
-        command, return_output=True,
-        machine=self.name, chromeos_root=self.chromeos_root)
-    b = if_out.splitlines()
-    a = [l for l in b if "Product" in l]
-    self.machine_id = a[0]
-    assert ret == 0, "Could not get machine_id from machine: %s" % self.name
-
-  def __str__(self):
-    l = []
-    l.append(self.name)
-    l.append(str(self.image))
-    l.append(str(self.checksum))
-    l.append(str(self.locked))
-    l.append(str(self.released_time))
-    return ", ".join(l)
-
-
-class MachineManager(object):
-  def __init__(self, chromeos_root, acquire_timeout):
-    self._lock = threading.RLock()
-    self._all_machines = []
-    self._machines = []
-    self.image_lock = threading.Lock()
-    self.num_reimages = 0
-    self.chromeos_root = None
-    self.machine_checksum = {}
-    self.machine_checksum_string = {}
-    self.acquire_timeout = acquire_timeout
-
-    if os.path.isdir(lock_machine.Machine.LOCKS_DIR):
-      self.no_lock = False
-    else:
-      self.no_lock = True
-    self._initialized_machines = []
-    self.chromeos_root = chromeos_root
-
-  def ImageMachine(self, machine, label):
-    checksum = ImageChecksummer().Checksum(label)
-    if machine.checksum == checksum:
-      return
-    chromeos_root = label.chromeos_root
-    if not chromeos_root:
-      chromeos_root = self.chromeos_root
-    image_chromeos_args = [image_chromeos.__file__,
-                           "--chromeos_root=%s" % chromeos_root,
-                           "--image=%s" % label.chromeos_image,
-                           "--image_args=%s" % label.image_args,
-                           "--remote=%s" % machine.name]
-    if label.board:
-      image_chromeos_args.append("--board=%s" % label.board)
-
-    # Currently can't image two machines at once.
-    # So have to serialized on this lock.
-    ce = command_executer.GetCommandExecuter()
-    with self.image_lock:
-      retval = ce.RunCommand(" ".join(["python"] + image_chromeos_args))
-      if retval:
-        raise Exception("Could not image machine: '%s'." % machine.name)
-      else:
-        self.num_reimages += 1
-      machine.checksum = checksum
-      machine.image = label.chromeos_image
-
-    return retval
-
-  def ComputeCommonCheckSum(self, label):
-    for machine in self.GetMachines(label):
-      if machine.machine_checksum:
-        self.machine_checksum[label.name] = machine.machine_checksum
-        break
-
-  def ComputeCommonCheckSumString(self, label):
-    for machine in self.GetMachines(label):
-      if machine.checksum_string:
-        self.machine_checksum_string[label.name] = machine.checksum_string
-        break
-
-  def _TryToLockMachine(self, cros_machine):
-    with self._lock:
-      assert cros_machine, "Machine can't be None"
-      for m in self._machines:
-        if m.name == cros_machine.name:
-          return
-      if self.no_lock:
-        locked = True
-      else:
-        locked = lock_machine.Machine(cros_machine.name).Lock(True, sys.argv[0])
-      if locked:
-        self._machines.append(cros_machine)
-        ce = command_executer.GetCommandExecuter()
-        command = "cat %s" % CHECKSUM_FILE
-        ret, out, _ = ce.CrosRunCommand(
-            command, return_output=True, chromeos_root=self.chromeos_root,
-            machine=cros_machine.name)
-        if ret == 0:
-          cros_machine.checksum = out.strip()
-      else:
-        logger.GetLogger().LogOutput("Couldn't lock: %s" % cros_machine.name)
-
-  # This is called from single threaded mode.
-  def AddMachine(self, machine_name):
-    with self._lock:
-      for m in self._all_machines:
-        assert m.name != machine_name, "Tried to double-add %s" % machine_name
-      cm = CrosMachine(machine_name, self.chromeos_root)
-      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
-                           machine_name)
-      self._all_machines.append(cm)
-
-  def AreAllMachineSame(self, label):
-    checksums = [m.machine_checksum for m in self.GetMachines(label)]
-    return len(set(checksums)) == 1
-
-  def AcquireMachine(self, chromeos_image, label):
-    image_checksum = ImageChecksummer().Checksum(label)
-    machines = self.GetMachines(label)
-    check_interval_time = 120
-    with self._lock:
-      # Lazily external lock machines
-      while self.acquire_timeout >= 0:
-        for m in machines:
-          new_machine = m not in self._all_machines
-          self._TryToLockMachine(m)
-          if new_machine:
-            m.released_time = time.time()
-        if not self.AreAllMachineSame(label):
-          logger.GetLogger().LogFatal("-- not all the machine are identical")
-        if self.GetAvailableMachines(label):
-          break
-        else:
-          sleep_time = max(1, min(self.acquire_timeout, check_interval_time))
-          time.sleep(sleep_time)
-          self.acquire_timeout -= sleep_time
-
-      if self.acquire_timeout < 0:
-        machine_names = []
-        for machine in machines:
-          machine_names.append(machine.name)
-        logger.GetLogger().LogFatal("Could not acquire any of the "
-                                    "following machines: '%s'"
-                                    % ", ".join(machine_names))
-
-###      for m in self._machines:
-###        if (m.locked and time.time() - m.released_time < 10 and
-###            m.checksum == image_checksum):
-###          return None
-      for m in [machine for machine in self.GetAvailableMachines(label)
-                if not machine.locked]:
-        if m.checksum == image_checksum:
-          m.locked = True
-          m.autotest_run = threading.current_thread()
-          return m
-      for m in [machine for machine in self.GetAvailableMachines(label)
-                if not machine.locked]:
-        if not m.checksum:
-          m.locked = True
-          m.autotest_run = threading.current_thread()
-          return m
-      # This logic ensures that threads waiting on a machine will get a machine
-      # with a checksum equal to their image over other threads. This saves time
-      # when crosperf initially assigns the machines to threads by minimizing
-      # the number of re-images.
-      # TODO(asharif): If we centralize the thread-scheduler, we wont need this
-      # code and can implement minimal reimaging code more cleanly.
-      for m in [machine for machine in self.GetAvailableMachines(label)
-                if not machine.locked]:
-        if time.time() - m.released_time > 20:
-          m.locked = True
-          m.autotest_run = threading.current_thread()
-          return m
-    return None
-
-  def GetAvailableMachines(self, label=None):
-    if not label:
-      return self._machines
-    return [m for m in self._machines if m.name in label.remote]
-
-  def GetMachines(self, label=None):
-    if not label:
-      return self._all_machines
-    return [m for m in self._all_machines if m.name in label.remote]
-
-  def ReleaseMachine(self, machine):
-    with self._lock:
-      for m in self._machines:
-        if machine.name == m.name:
-          assert m.locked == True, "Tried to double-release %s" % m.name
-          m.released_time = time.time()
-          m.locked = False
-          m.status = "Available"
-          break
-
-  def Cleanup(self):
-    with self._lock:
-      # Unlock all machines.
-      for m in self._machines:
-        if not self.no_lock:
-          res = lock_machine.Machine(m.name).Unlock(True)
-          if not res:
-            logger.GetLogger().LogError("Could not unlock machine: '%s'."
-                                        % m.name)
-
-  def __str__(self):
-    with self._lock:
-      l = ["MachineManager Status:"]
-      for m in self._machines:
-        l.append(str(m))
-      return "\n".join(l)
-
-  def AsString(self):
-    with self._lock:
-      stringify_fmt = "%-30s %-10s %-4s %-25s %-32s"
-      header = stringify_fmt % ("Machine", "Thread", "Lock", "Status",
-                                "Checksum")
-      table = [header]
-      for m in self._machines:
-        if m.autotest_run:
-          autotest_name = m.autotest_run.name
-          autotest_status = m.autotest_run.timeline.GetLastEvent()
-        else:
-          autotest_name = ""
-          autotest_status = ""
-
-        try:
-          machine_string = stringify_fmt % (m.name,
-                                            autotest_name,
-                                            m.locked,
-                                            autotest_status,
-                                            m.checksum)
-        except Exception:
-          machine_string = ""
-        table.append(machine_string)
-      return "Machine Status:\n%s" % "\n".join(table)
-
-  def GetAllCPUInfo(self, labels):
-    """Get cpuinfo for labels, merge them if their cpuinfo are the same."""
-    dic = {}
-    for label in labels:
-      for machine in self._all_machines:
-        if machine.name in label.remote:
-          if machine.cpuinfo not in dic:
-            dic[machine.cpuinfo] = [label.name]
-          else:
-            dic[machine.cpuinfo].append(label.name)
-          break
-    output = ""
-    for key, v in dic.items():
-      output += " ".join(v)
-      output += "\n-------------------\n"
-      output += key
-      output += "\n\n\n"
-    return output
-
-
-class MockCrosMachine(CrosMachine):
-  def __init__(self, name, chromeos_root):
-    self.name = name
-    self.image = None
-    self.checksum = None
-    self.locked = False
-    self.released_time = time.time()
-    self.autotest_run = None
-    self.chromeos_root = chromeos_root
-    self.checksum_string = re.sub("\d", "", name)
-    #In test, we assume "lumpy1", "lumpy2" are the same machine.
-    self.machine_checksum =  self._GetMD5Checksum(self.checksum_string)
-
-
-class MockMachineManager(MachineManager):
-
-  def __init__(self, chromeos_root, acquire_timeout):
-    super(MockMachineManager, self).__init__(chromeos_root, acquire_timeout)
-
-  def _TryToLockMachine(self, cros_machine):
-    self._machines.append(cros_machine)
-    cros_machine.checksum = ""
-
-  def AddMachine(self, machine_name):
-    with self._lock:
-      for m in self._all_machines:
-        assert m.name != machine_name, "Tried to double-add %s" % machine_name
-      cm = MockCrosMachine(machine_name, self.chromeos_root)
-      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
-                                   machine_name)
-      self._all_machines.append(cm)
-
-  def AcquireMachine(self, chromeos_image, label):
-    for machine in self._all_machines:
-      if not machine.locked:
-        machine.locked = True
-        return machine
-    return None
-
-  def ImageMachine(self, machine_name, label):
-    return 0
-
-  def ReleaseMachine(self, machine):
-    machine.locked = False
-
-  def GetMachines(self, label):
-    return self._all_machines
-
-  def GetAvailableMachines(self, label):
-    return self._all_machines
diff --git a/v14/crosperf/machine_manager_unittest.py b/v14/crosperf/machine_manager_unittest.py
deleted file mode 100755
index 84266d5e..00000000
--- a/v14/crosperf/machine_manager_unittest.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""Unittest for machine_manager."""
-import unittest
-
-import label
-import machine_manager
-
-
-class MyMachineManager(machine_manager.MachineManager):
-
-  def __init__(self, chromeos_root):
-    super(MyMachineManager, self).__init__(chromeos_root, 0)
-
-  def _TryToLockMachine(self, cros_machine):
-    self._machines.append(cros_machine)
-    cros_machine.checksum = ""
-
-  def AddMachine(self, machine_name):
-    with self._lock:
-      for m in self._all_machines:
-        assert m.name != machine_name, "Tried to double-add %s" % machine_name
-      cm = machine_manager.MockCrosMachine(machine_name, self.chromeos_root)
-      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
-                                   machine_name)
-      self._all_machines.append(cm)
-
-CHROMEOS_ROOT = "/tmp/chromeos-root"
-MACHINE_NAMES = ["lumpy1", "lumpy2", "lumpy3", "daisy1", "daisy2"]
-LABEL_LUMPY = label.MockLabel("lumpy", "image", CHROMEOS_ROOT, "lumpy",
-                              ["lumpy1", "lumpy2", "lumpy3", "lumpy4"],
-                              "", "", "")
-LABEL_MIX = label.MockLabel("mix", "image", CHROMEOS_ROOT, "mix",
-                            ["daisy1", "daisy2", "lumpy3", "lumpy4"],
-                            "", "", "")
-
-
-class MachineManagerTest(unittest.TestCase):
-
-  def testAreAllMachineSame(self):
-    manager = MyMachineManager(CHROMEOS_ROOT)
-    for m in MACHINE_NAMES:
-      manager.AddMachine(m)
-    self.assertEqual(manager.AreAllMachineSame(LABEL_LUMPY), True)
-    self.assertEqual(manager.AreAllMachineSame(LABEL_MIX), False)
-
-  def testGetMachines(self):
-    manager = MyMachineManager(CHROMEOS_ROOT)
-    for m in MACHINE_NAMES:
-      manager.AddMachine(m)
-    names = [m.name for m in manager.GetMachines(LABEL_LUMPY)]
-    self.assertEqual(names, ["lumpy1", "lumpy2", "lumpy3"])
-
-  def testGetAvailableMachines(self):
-    manager = MyMachineManager(CHROMEOS_ROOT)
-    for m in MACHINE_NAMES:
-      manager.AddMachine(m)
-    for m in manager._all_machines:
-      if int(m.name[-1]) % 2:
-        manager._TryToLockMachine(m)
-    names = [m.name for m in manager.GetAvailableMachines(LABEL_LUMPY)]
-    self.assertEqual(names, ["lumpy1", "lumpy3"])
-
-if __name__ == "__main__":
-  unittest.main()
diff --git a/v14/crosperf/perf_table.py b/v14/crosperf/perf_table.py
deleted file mode 100644
index 3c8b88b8..00000000
--- a/v14/crosperf/perf_table.py
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-"""Parse perf report data for tabulator."""
-
-import os
-
-from utils import perf_diff
-
-
-def ParsePerfReport(perf_file):
-  """It should return a dict."""
-
-  return {"cycles": {"foo": 10, "bar": 20},
-          "cache_miss": {"foo": 20, "bar": 10}}
-
-
-class PerfTable(object):
-  """The class to generate dicts for tabulator."""
-
-  def __init__(self, experiment, label_names):
-    self._experiment = experiment
-    self._label_names = label_names
-    self.perf_data = {}
-    self.GenerateData()
-
-    # {benchmark:{perf_event1:[[{func1:number, func2:number,
-    #                             rows_to_show: number}
-    #                           {func1: number, func2: number
-    #                             rows_to_show: number}]], ...},
-    #  benchmark2:...}
-    # The rows_to_show is temp data recording how many
-    # rows have over 1% running time.
-    self.row_info = {}
-    self.GetRowsToShow()
-
-  def GenerateData(self):
-    for label in self._label_names:
-      for benchmark in self._experiment.benchmarks:
-        for i in range(1, benchmark.iterations+1):
-          dir_name = label + benchmark.name + str(i)
-          dir_name = filter(str.isalnum, dir_name)
-          perf_file = os.path.join(self._experiment.results_directory,
-                                   dir_name,
-                                   "perf.data.report.0")
-          self.ReadPerfReport(perf_file, label, benchmark.name, i - 1)
-
-  def ReadPerfReport(self, perf_file, label, benchmark_name, iteration):
-    """Add the data from one run to the dict."""
-    if os.path.isfile(perf_file):
-      perf_of_run = perf_diff.GetPerfDictFromReport(perf_file)
-    else:
-      perf_of_run = {}
-    if benchmark_name not in self.perf_data:
-      self.perf_data[benchmark_name] = {}
-      for event in perf_of_run:
-        self.perf_data[benchmark_name][event] = []
-    ben_data = self.perf_data[benchmark_name]
-
-    label_index = self._label_names.index(label)
-    for event in ben_data:
-      while len(ben_data[event]) <= label_index:
-        ben_data[event].append([])
-      data_for_label = ben_data[event][label_index]
-      while len(data_for_label) <= iteration:
-        data_for_label.append({})
-      if perf_of_run:
-        data_for_label[iteration] = perf_of_run[event]
-      else:
-        data_for_label[iteration] = {}
-
-  def GetRowsToShow(self):
-    for benchmark in self.perf_data:
-      if benchmark not in self.row_info:
-        self.row_info[benchmark] = {}
-      for event in self.perf_data[benchmark]:
-        rows = 0
-        for run in self.perf_data[benchmark][event]:
-          for iteration in run:
-            if perf_diff.ROWS_TO_SHOW in iteration:
-              rows = max(iteration[perf_diff.ROWS_TO_SHOW], rows)
-              # delete the temp data which stores how many rows of
-              # the perf data have over 1% running time.
-              del iteration[perf_diff.ROWS_TO_SHOW]
-        self.row_info[benchmark][event] = rows
diff --git a/v14/crosperf/results_cache.py b/v14/crosperf/results_cache.py
deleted file mode 100644
index 0357275d..00000000
--- a/v14/crosperf/results_cache.py
+++ /dev/null
@@ -1,417 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import getpass
-import glob
-import hashlib
-import os
-import pickle
-import re
-import tempfile
-
-from utils import command_executer
-from utils import misc
-
-from image_checksummer import ImageChecksummer
-
-SCRATCH_BASE = "/home/%s/cros_scratch"
-SCRATCH_DIR = SCRATCH_BASE % getpass.getuser()
-RESULTS_FILE = "results.txt"
-MACHINE_FILE = "machine.txt"
-AUTOTEST_TARBALL = "autotest.tbz2"
-PERF_RESULTS_FILE = "perf-results.txt"
-
-
-class Result(object):
-  """ This class manages what exactly is stored inside the cache without knowing
-  what the key of the cache is. For runs with perf, it stores perf.data,
-  perf.report, etc. The key generation is handled by the ResultsCache class.
-  """
-
-  def __init__(self, chromeos_root, logger, label_name):
-    self._chromeos_root = chromeos_root
-    self._logger = logger
-    self._ce = command_executer.GetCommandExecuter(self._logger)
-    self._temp_dir = None
-    self.label_name = label_name
-
-  def _CopyFilesTo(self, dest_dir, files_to_copy):
-    file_index = 0
-    for file_to_copy in files_to_copy:
-      if not os.path.isdir(dest_dir):
-        command = "mkdir -p %s" % dest_dir
-        self._ce.RunCommand(command)
-      dest_file = os.path.join(dest_dir,
-                               ("%s.%s" % (os.path.basename(file_to_copy),
-                                           file_index)))
-      ret = self._ce.CopyFiles(file_to_copy,
-                               dest_file,
-                               recursive=False)
-      if ret:
-        raise Exception("Could not copy results file: %s" % file_to_copy)
-
-  def CopyResultsTo(self, dest_dir):
-    self._CopyFilesTo(dest_dir, self.perf_data_files)
-    self._CopyFilesTo(dest_dir, self.perf_report_files)
-
-  def _GetKeyvals(self):
-    results_in_chroot = os.path.join(self._chromeos_root,
-                                     "chroot", "tmp")
-    if not self._temp_dir:
-      self._temp_dir = tempfile.mkdtemp(dir=results_in_chroot)
-      command = "cp -r {0}/* {1}".format(self.results_dir, self._temp_dir)
-      self._ce.RunCommand(command)
-
-    command = ("python generate_test_report --no-color --csv %s" %
-               (os.path.join("/tmp", os.path.basename(self._temp_dir))))
-    [_, out, _] = self._ce.ChrootRunCommand(self._chromeos_root,
-                                            command,
-                                            return_output=True)
-    keyvals_dict = {}
-    for line in out.splitlines():
-      tokens = re.split("=|,", line)
-      key = tokens[-2]
-      if key.startswith(self.results_dir):
-        key = key[len(self.results_dir) + 1:]
-      value = tokens[-1]
-      keyvals_dict[key] = value
-
-    return keyvals_dict
-
-  def _GetResultsDir(self):
-    mo = re.search(r"Results placed in (\S+)", self.out)
-    if mo:
-      result = mo.group(1)
-      return result
-    raise Exception("Could not find results directory.")
-
-  def _FindFilesInResultsDir(self, find_args):
-    command = "find %s %s" % (self.results_dir,
-                              find_args)
-    ret, out, _ = self._ce.RunCommand(command, return_output=True)
-    if ret:
-      raise Exception("Could not run find command!")
-    return out
-
-  def _GetPerfDataFiles(self):
-    return self._FindFilesInResultsDir("-name perf.data").splitlines()
-
-  def _GetPerfReportFiles(self):
-    return self._FindFilesInResultsDir("-name perf.data.report").splitlines()
-
-  def _GeneratePerfReportFiles(self):
-    perf_report_files = []
-    for perf_data_file in self.perf_data_files:
-      # Generate a perf.report and store it side-by-side with the perf.data
-      # file.
-      chroot_perf_data_file = misc.GetInsideChrootPath(self._chromeos_root,
-                                                       perf_data_file)
-      perf_report_file = "%s.report" % perf_data_file
-      if os.path.exists(perf_report_file):
-        raise Exception("Perf report file already exists: %s" %
-                        perf_report_file)
-      chroot_perf_report_file = misc.GetInsideChrootPath(self._chromeos_root,
-                                                         perf_report_file)
-      command = ("/usr/sbin/perf report "
-                 "-n "
-                 "--symfs /build/%s "
-                 "--vmlinux /build/%s/usr/lib/debug/boot/vmlinux "
-                 "--kallsyms /build/%s/boot/System.map-* "
-                 "-i %s --stdio "
-                 "> %s" %
-                 (self._board,
-                  self._board,
-                  self._board,
-                  chroot_perf_data_file,
-                  chroot_perf_report_file))
-      self._ce.ChrootRunCommand(self._chromeos_root,
-                                command)
-
-      # Add a keyval to the dictionary for the events captured.
-      perf_report_files.append(
-          misc.GetOutsideChrootPath(self._chromeos_root,
-                                    chroot_perf_report_file))
-    return perf_report_files
-
-  def _GatherPerfResults(self):
-    report_id = 0
-    for perf_report_file in self.perf_report_files:
-      with open(perf_report_file, "r") as f:
-        report_contents = f.read()
-        for group in re.findall(r"Events: (\S+) (\S+)", report_contents):
-          num_events = group[0]
-          event_name = group[1]
-          key = "perf_%s_%s" % (report_id, event_name)
-          value = str(misc.UnitToNumber(num_events))
-          self.keyvals[key] = value
-
-  def _PopulateFromRun(self, board, out, err, retval):
-    self._board = board
-    self.out = out
-    self.err = err
-    self.retval = retval
-    self.chroot_results_dir = self._GetResultsDir()
-    self.results_dir = misc.GetOutsideChrootPath(self._chromeos_root,
-                                                 self.chroot_results_dir)
-    self.perf_data_files = self._GetPerfDataFiles()
-    # Include all perf.report data in table.
-    self.perf_report_files = self._GeneratePerfReportFiles()
-    # TODO(asharif): Do something similar with perf stat.
-
-    # Grab keyvals from the directory.
-    self._ProcessResults()
-
-  def _ProcessResults(self):
-    # Note that this function doesn't know anything about whether there is a
-    # cache hit or miss. It should process results agnostic of the cache hit
-    # state.
-    self.keyvals = self._GetKeyvals()
-    self.keyvals["retval"] = self.retval
-    # Generate report from all perf.data files.
-    # Now parse all perf report files and include them in keyvals.
-    self._GatherPerfResults()
-
-  def _PopulateFromCacheDir(self, cache_dir):
-    # Read in everything from the cache directory.
-    with open(os.path.join(cache_dir, RESULTS_FILE), "r") as f:
-      self.out = pickle.load(f)
-      self.err = pickle.load(f)
-      self.retval = pickle.load(f)
-
-    # Untar the tarball to a temporary directory
-    self._temp_dir = tempfile.mkdtemp(dir=os.path.join(self._chromeos_root,
-                                                       "chroot", "tmp"))
-
-    command = ("cd %s && tar xf %s" %
-               (self._temp_dir,
-                os.path.join(cache_dir, AUTOTEST_TARBALL)))
-    ret = self._ce.RunCommand(command)
-    if ret:
-      raise Exception("Could not untar cached tarball")
-    self.results_dir = self._temp_dir
-    self.perf_data_files = self._GetPerfDataFiles()
-    self.perf_report_files = self._GetPerfReportFiles()
-    self._ProcessResults()
-
-  def CleanUp(self, rm_chroot_tmp):
-    if rm_chroot_tmp:
-      command = "rm -rf %s" % self.results_dir
-      self._ce.RunCommand(command)
-    if self._temp_dir:
-      command = "rm -rf %s" % self._temp_dir
-      self._ce.RunCommand(command)
-
-  def StoreToCacheDir(self, cache_dir, machine_manager):
-    # Create the dir if it doesn't exist.
-    temp_dir = tempfile.mkdtemp()
-
-    # Store to the temp directory.
-    with open(os.path.join(temp_dir, RESULTS_FILE), "w") as f:
-      pickle.dump(self.out, f)
-      pickle.dump(self.err, f)
-      pickle.dump(self.retval, f)
-
-    tarball = os.path.join(temp_dir, AUTOTEST_TARBALL)
-    command = ("cd %s && "
-               "tar "
-               "--exclude=var/spool "
-               "--exclude=var/log "
-               "-cjf %s ." % (self.results_dir, tarball))
-    ret = self._ce.RunCommand(command)
-    if ret:
-      raise Exception("Couldn't store autotest output directory.")
-    # Store machine info.
-    # TODO(asharif): Make machine_manager a singleton, and don't pass it into
-    # this function.
-    with open(os.path.join(temp_dir, MACHINE_FILE), "w") as f:
-      f.write(machine_manager.machine_checksum_string[self.label_name])
-
-    if os.path.exists(cache_dir):
-      command = "rm -rf {0}".format(cache_dir)
-      self._ce.RunCommand(command)
-
-    command = "mkdir -p {0} && ".format(os.path.dirname(cache_dir))
-    command += "mv {0} {1}".format(temp_dir, cache_dir)
-    ret = self._ce.RunCommand(command)
-    if ret:
-      command = "rm -rf {0}".format(temp_dir)
-      self._ce.RunCommand(command)
-      raise Exception("Could not move dir %s to dir %s" %
-                      (temp_dir, cache_dir))
-
-  @classmethod
-  def CreateFromRun(cls, logger, chromeos_root, board, label_name,
-                    out, err, retval):
-    result = cls(chromeos_root, logger, label_name)
-    result._PopulateFromRun(board, out, err, retval)
-    return result
-
-  @classmethod
-  def CreateFromCacheHit(cls, chromeos_root, logger, cache_dir, label_name):
-    result = cls(chromeos_root, logger, label_name)
-    try:
-      result._PopulateFromCacheDir(cache_dir)
-    except Exception as e:
-      logger.LogError("Exception while using cache: %s" % e)
-      return None
-    return result
-
-
-class CacheConditions(object):
-  # Cache hit only if the result file exists.
-  CACHE_FILE_EXISTS = 0
-
-  # Cache hit if the checksum of cpuinfo and totalmem of
-  # the cached result and the new run match.
-  MACHINES_MATCH = 1
-
-  # Cache hit if the image checksum of the cached result and the new run match.
-  CHECKSUMS_MATCH = 2
-
-  # Cache hit only if the cached result was successful
-  RUN_SUCCEEDED = 3
-
-  # Never a cache hit.
-  FALSE = 4
-
-  # Cache hit if the image path matches the cached image path.
-  IMAGE_PATH_MATCH = 5
-
-  # Cache hit if the uuid of hard disk mataches the cached one
-
-  SAME_MACHINE_MATCH = 6
-
-
-class ResultsCache(object):
-  """ This class manages the key of the cached runs without worrying about what
-  is exactly stored (value). The value generation is handled by the Results
-  class.
-  """
-  CACHE_VERSION = 6
-
-  def Init(self, chromeos_image, chromeos_root, autotest_name, iteration,
-           autotest_args, machine_manager, board, cache_conditions,
-           logger_to_use, label, share_users):
-    self.chromeos_image = chromeos_image
-    self.chromeos_root = chromeos_root
-    self.autotest_name = autotest_name
-    self.iteration = iteration
-    self.autotest_args = autotest_args,
-    self.board = board
-    self.cache_conditions = cache_conditions
-    self.machine_manager = machine_manager
-    self._logger = logger_to_use
-    self._ce = command_executer.GetCommandExecuter(self._logger)
-    self.label = label
-    self.share_users = share_users
-
-  def _GetCacheDirForRead(self):
-    matching_dirs = []
-    for glob_path in self._FormCacheDir(self._GetCacheKeyList(True)):
-      matching_dirs += glob.glob(glob_path)
-
-    if matching_dirs:
-      # Cache file found.
-      return matching_dirs[0]
-    else:
-      return None
-
-  def _GetCacheDirForWrite(self):
-    return self._FormCacheDir(self._GetCacheKeyList(False))[0]
-
-  def _FormCacheDir(self, list_of_strings):
-    cache_key = " ".join(list_of_strings)
-    cache_dir = misc.GetFilenameFromString(cache_key)
-    if self.label.cache_dir:
-      cache_home = os.path.abspath(os.path.expanduser(self.label.cache_dir))
-      cache_path = [os.path.join(cache_home, cache_dir)]
-    else:
-      cache_path = [os.path.join(SCRATCH_DIR, cache_dir)]
-
-    for i in [x.strip() for x in self.share_users.split(",")]:
-      path = SCRATCH_BASE % i
-      cache_path.append(os.path.join(path, cache_dir))
-
-    return cache_path
-
-  def _GetCacheKeyList(self, read):
-    if read and CacheConditions.MACHINES_MATCH not in self.cache_conditions:
-      machine_checksum = "*"
-    else:
-      machine_checksum = self.machine_manager.machine_checksum[self.label.name]
-    if read and CacheConditions.CHECKSUMS_MATCH not in self.cache_conditions:
-      checksum = "*"
-    else:
-      checksum = ImageChecksummer().Checksum(self.label)
-
-    if read and CacheConditions.IMAGE_PATH_MATCH not in self.cache_conditions:
-      image_path_checksum = "*"
-    else:
-      image_path_checksum = hashlib.md5(self.chromeos_image).hexdigest()
-
-    if read and CacheConditions.SAME_MACHINE_MATCH not in self.cache_conditions:
-      machine_id_checksum = "*"
-    else:
-      for machine in self.machine_manager.GetMachines(self.label):
-        if machine.name == self.label.remote[0]:
-          machine_id_checksum = machine.machine_id_checksum
-          break
-
-    autotest_args_checksum = hashlib.md5(
-        "".join(self.autotest_args)).hexdigest()
-    return (image_path_checksum,
-            self.autotest_name, str(self.iteration),
-            autotest_args_checksum,
-            checksum,
-            machine_checksum,
-            machine_id_checksum,
-            str(self.CACHE_VERSION))
-
-  def ReadResult(self):
-    if CacheConditions.FALSE in self.cache_conditions:
-      return None
-    cache_dir = self._GetCacheDirForRead()
-
-    if not cache_dir:
-      return None
-
-    if not os.path.isdir(cache_dir):
-      return None
-
-    self._logger.LogOutput("Trying to read from cache dir: %s" % cache_dir)
-
-    result = Result.CreateFromCacheHit(self.chromeos_root,
-                                       self._logger, cache_dir, self.label.name)
-
-    if not result:
-      return None
-
-    if (result.retval == 0 or
-        CacheConditions.RUN_SUCCEEDED not in self.cache_conditions):
-      return result
-
-    return None
-
-  def StoreResult(self, result):
-    cache_dir = self._GetCacheDirForWrite()
-    result.StoreToCacheDir(cache_dir, self.machine_manager)
-
-
-class MockResultsCache(ResultsCache):
-  def Init(self, *args):
-    pass
-
-  def ReadResult(self):
-    return None
-
-  def StoreResult(self, result):
-    pass
-
-
-class MockResult(Result):
-  def _PopulateFromRun(self, out, err, retval):
-    self.out = out
-    self.err = err
-    self.retval = retval
-
diff --git a/v14/crosperf/results_organizer.py b/v14/crosperf/results_organizer.py
deleted file mode 100644
index 2e5c9296..00000000
--- a/v14/crosperf/results_organizer.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2012 Google Inc. All Rights Reserved.
-"""Parse data from benchmark_runs for tabulator."""
-import re
-
-
-class ResultOrganizer(object):
-  """Create a dict from benchmark_runs.
-
-  The structure of the output dict is as follows:
-  {"benchmark_1":[
-    [{"key1":"v1", "key2":"v2"},{"key1":"v1", "key2","v2"}]
-    #one label
-    []
-    #the other label
-    ]
-   "benchmark_2":
-    [
-    ]}.
-  """
-  key_filter = ["milliseconds_",
-                "retval",
-                "iterations",
-                "ms_",
-                "score_"]
-
-  def __init__(self, benchmark_runs, labels, benchmarks=None):
-    self.result = {}
-    self.labels = []
-    self.prog = re.compile(r"(\w+)\{(\d+)\}")
-    self.benchmarks = benchmarks
-    if not self.benchmarks:
-      self.benchmarks = []
-    for label in labels:
-      self.labels.append(label.name)
-    for benchmark_run in benchmark_runs:
-      benchmark_name = benchmark_run.benchmark.name
-      if benchmark_name not in self.result:
-        self.result[benchmark_name] = []
-        while len(self.result[benchmark_name]) < len(labels):
-          self.result[benchmark_name].append([])
-      label_index = self.labels.index(benchmark_run.label.name)
-      cur_table = self.result[benchmark_name][label_index]
-      index = benchmark_run.iteration - 1
-      while index >= len(cur_table):
-        cur_table.append({})
-      cur_dict = cur_table[index]
-      if not benchmark_run.result:
-        continue
-      benchmark = benchmark_run.benchmark
-      key_filter_on = (benchmark.key_results_only and
-                       "PyAutoPerfTest" in benchmark.name + benchmark.autotest_name and
-                       "perf." not in benchmark.autotest_args)
-      for autotest_key in benchmark_run.result.keyvals:
-        if (key_filter_on and
-            not any([key for key in self.key_filter if key in autotest_key])
-           ):
-          continue
-        result_value = benchmark_run.result.keyvals[autotest_key]
-        cur_dict[autotest_key] = result_value
-    self._DuplicatePass()
-
-  def _DuplicatePass(self):
-    for bench, data in self.result.items():
-      max_dup = self._GetMaxDup(data)
-      if not max_dup:
-        continue
-      for label in data:
-        index = data.index(label)
-        data[index] = self._GetNonDupLabel(max_dup, label)
-      self._AdjustIteration(max_dup, bench)
-
-  def _GetMaxDup(self, data):
-    """Find the maximum i inside ABCD{i}."""
-    max_dup = 0
-    for label in data:
-      for run in label:
-        for key in run:
-          if re.match(self.prog, key):
-            max_dup = max(max_dup,
-                          int(re.search(self.prog, key).group(2)))
-    return max_dup
-
-  def _GetNonDupLabel(self, max_dup, label):
-    """Create new list for the runs of the same label."""
-    new_label = []
-    for run in label:
-      start_index = len(new_label)
-      new_label.append(dict(run))
-      for i in range(max_dup):
-        new_label.append({})
-      new_run = new_label[start_index]
-      for key, value in new_run.items():
-        if re.match(self.prog, key):
-          new_key = re.search(self.prog, key).group(1)
-          index = int(re.search(self.prog, key).group(2))
-          new_label[start_index+index][new_key] = str(value)
-          del new_run[key]
-    return new_label
-
-  def _AdjustIteration(self, max_dup, bench):
-    """Adjust the interation numbers if the have keys like ABCD{i}."""
-    for benchmark in self.benchmarks:
-      if benchmark.name == bench:
-        if not benchmark.iteration_adjusted:
-          benchmark.iteration_adjusted = True
-          benchmark.iterations *= (max_dup +1)
diff --git a/v14/crosperf/results_report.py b/v14/crosperf/results_report.py
deleted file mode 100644
index 61c67d5b..00000000
--- a/v14/crosperf/results_report.py
+++ /dev/null
@@ -1,502 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-from utils.tabulator import *
-
-from column_chart import ColumnChart
-from results_organizer import ResultOrganizer
-from perf_table import PerfTable
-
-
-class ResultsReport(object):
-  MAX_COLOR_CODE = 255
-  PERF_ROWS = 5
-
-  def __init__(self, experiment):
-    self.experiment = experiment
-    self.benchmark_runs = experiment.benchmark_runs
-    self.labels = experiment.labels
-    self.benchmarks = experiment.benchmarks
-    self.baseline = self.labels[0]
-
-  def _SortByLabel(self, runs):
-    labels = {}
-    for benchmark_run in runs:
-      if benchmark_run.label_name not in labels:
-        labels[benchmark_run.label_name] = []
-      labels[benchmark_run.label_name].append(benchmark_run)
-    return labels
-
-  def GetFullTables(self, perf=False):
-    columns = [Column(NonEmptyCountResult(),
-                      Format(),
-                      "Completed"),
-               Column(RawResult(),
-                      Format()),
-               Column(MinResult(),
-                      Format()),
-               Column(MaxResult(),
-                      Format()),
-               Column(AmeanResult(),
-                      Format()),
-               Column(StdResult(),
-                      Format(), "StdDev"),
-               Column(CoeffVarResult(),
-                      CoeffVarFormat(), "StdDev/Mean"),
-               Column(GmeanRatioResult(),
-                      RatioFormat(), "GmeanSpeedup"),
-               Column(PValueResult(),
-                      PValueFormat(), "p-value")
-              ]
-    if not perf:
-      return self._GetTables(self.labels, self.benchmark_runs, columns)
-    return self. _GetPerfTables(self.labels, columns)
-
-  def GetSummaryTables(self, perf=False):
-    columns = [Column(NonEmptyCountResult(),
-                      Format(),
-                      "Completed"),
-               Column(AmeanResult(),
-                      Format()),
-               Column(StdResult(),
-                      Format(), "StdDev"),
-               Column(CoeffVarResult(),
-                      CoeffVarFormat(), "StdDev/Mean"),
-               Column(GmeanRatioResult(),
-                      RatioFormat(), "GmeanSpeedup"),
-               Column(GmeanRatioResult(),
-                      ColorBoxFormat(), " "),
-               Column(PValueResult(),
-                      PValueFormat(), "p-value")
-              ]
-    if not perf:
-      return self._GetTables(self.labels, self.benchmark_runs, columns)
-    return self. _GetPerfTables(self.labels, columns)
-
-  def _ParseColumn(self, columns, iteration):
-    new_column = []
-    for column in columns:
-      if column.result.__class__.__name__ != "RawResult":
-      #TODO(asharif): tabulator should support full table natively.
-        new_column.append(column)
-      else:
-        for i in range(iteration):
-          cc = Column(LiteralResult(i), Format(), str(i+1))
-          new_column.append(cc)
-    return new_column
-
-  def _AreAllRunsEmpty(self, runs):
-    for label in runs:
-      for dictionary in label:
-        if dictionary:
-          return False
-    return True
-
-  def _GetTableHeader(self, benchmark):
-    benchmark_info = ("Benchmark:  {0};  Iterations: {1}"
-                      .format(benchmark.name, benchmark.iterations))
-    cell = Cell()
-    cell.string_value = benchmark_info
-    cell.header = True
-    return  [[cell]]
-
-  def _GetTables(self, labels, benchmark_runs, columns):
-    tables = []
-    ro = ResultOrganizer(benchmark_runs, labels, self.benchmarks)
-    result = ro.result
-    label_name = ro.labels
-    for item in result:
-      runs = result[item]
-      for benchmark in self.benchmarks:
-        if benchmark.name == item:
-          break
-      ben_table = self._GetTableHeader(benchmark)
-
-      if  self._AreAllRunsEmpty(runs):
-        cell = Cell()
-        cell.string_value = ("This benchmark contains no result."
-                             " Is the benchmark name valid?")
-        cell_table = [[cell]]
-      else:
-        tg = TableGenerator(runs, label_name)
-        table = tg.GetTable()
-        parsed_columns = self._ParseColumn(columns, benchmark.iterations)
-        tf = TableFormatter(table, parsed_columns)
-        cell_table = tf.GetCellTable()
-      tables.append(ben_table)
-      tables.append(cell_table)
-    return tables
-
-  def _GetPerfTables(self, labels, columns):
-    tables = []
-    label_names = [label.name for label in labels]
-    p_table = PerfTable(self.experiment, label_names)
-
-    if not p_table.perf_data:
-      return tables
-
-    for benchmark in p_table.perf_data:
-      ben = None
-      for ben in self.benchmarks:
-        if ben.name == benchmark:
-          break
-
-      ben_table = self._GetTableHeader(ben)
-      tables.append(ben_table)
-      benchmark_data = p_table.perf_data[benchmark]
-      row_info = p_table.row_info[benchmark]
-      table = []
-      for event in benchmark_data:
-        tg = TableGenerator(benchmark_data[event], label_names,
-                            sort=TableGenerator.SORT_BY_VALUES_DESC)
-        table = tg.GetTable(max(self.PERF_ROWS, row_info[event]))
-        parsed_columns = self._ParseColumn(columns, ben.iterations)
-        tf = TableFormatter(table, parsed_columns)
-        tf.GenerateCellTable()
-        tf.AddColumnName()
-        tf.AddLabelName()
-        tf.AddHeader(str(event))
-        table = tf.GetCellTable(headers=False)
-        tables.append(table)
-    return tables
-
-  def PrintTables(self, tables, out_to):
-    output = ""
-    if not tables:
-      return output
-    for table in tables:
-      if out_to == "HTML":
-        tp = TablePrinter(table, TablePrinter.HTML)
-      elif out_to == "PLAIN":
-        tp = TablePrinter(table, TablePrinter.PLAIN)
-      elif out_to == "CONSOLE":
-        tp = TablePrinter(table, TablePrinter.CONSOLE)
-      elif out_to == "TSV":
-        tp = TablePrinter(table, TablePrinter.TSV)
-      elif out_to == "EMAIL":
-        tp = TablePrinter(table, TablePrinter.EMAIL)
-      else:
-        pass
-      output += tp.Print()
-    return output
-
-
-class TextResultsReport(ResultsReport):
-  TEXT = """
-===========================================
-Results report for: '%s'
-===========================================
-
--------------------------------------------
-Summary
--------------------------------------------
-%s
-
-
-Number re-images: %s
-
--------------------------------------------
-Benchmark Run Status
--------------------------------------------
-%s
-
-
--------------------------------------------
-Perf Data
--------------------------------------------
-%s
-
-
-
-Experiment File
--------------------------------------------
-%s
-
-
-CPUInfo
--------------------------------------------
-%s
-===========================================
-"""
-
-  def __init__(self, experiment, email=False):
-    super(TextResultsReport, self).__init__(experiment)
-    self.email = email
-
-  def GetStatusTable(self):
-    """Generate the status table by the tabulator."""
-    table = [["", ""]]
-    columns = [Column(LiteralResult(iteration=0), Format(), "Status"),
-               Column(LiteralResult(iteration=1), Format(), "Failing Reason")]
-
-    for benchmark_run in self.benchmark_runs:
-      status = [benchmark_run.name, [benchmark_run.timeline.GetLastEvent(),
-                                     benchmark_run.failure_reason]]
-      table.append(status)
-    tf = TableFormatter(table, columns)
-    cell_table = tf.GetCellTable()
-    return [cell_table]
-
-  def GetReport(self):
-    """Generate the report for email and console."""
-    status_table = self.GetStatusTable()
-    summary_table = self.GetSummaryTables()
-    full_table = self.GetFullTables()
-    perf_table = self.GetSummaryTables(perf=True)
-    if not perf_table:
-      perf_table = None
-    if not self.email:
-      return self.TEXT % (self.experiment.name,
-                          self.PrintTables(summary_table, "CONSOLE"),
-                          self.experiment.machine_manager.num_reimages,
-                          self.PrintTables(status_table, "CONSOLE"),
-                          self.PrintTables(perf_table, "CONSOLE"),
-                          self.experiment.experiment_file,
-                          self.experiment.machine_manager.GetAllCPUInfo(
-                              self.experiment.labels))
-
-    return self.TEXT % (self.experiment.name,
-                        self.PrintTables(summary_table, "EMAIL"),
-                        self.experiment.machine_manager.num_reimages,
-                        self.PrintTables(status_table, "EMAIL"),
-                        self.PrintTables(perf_table, "EMAIL"),
-                        self.experiment.experiment_file,
-                        self.experiment.machine_manager.GetAllCPUInfo(
-                            self.experiment.labels))
-
-
-class HTMLResultsReport(ResultsReport):
-
-  HTML = """
-<html>
-  <head>
-    <style type="text/css">
-
-body {
-  font-family: "Lucida Sans Unicode", "Lucida Grande", Sans-Serif;
-  font-size: 12px;
-}
-
-pre {
-  margin: 10px;
-  color: #039;
-  font-size: 14px;
-}
-
-.chart {
-  display: inline;
-}
-
-.hidden {
-  visibility: hidden;
-}
-
-.results-section {
-  border: 1px solid #b9c9fe;
-  margin: 10px;
-}
-
-.results-section-title {
-  background-color: #b9c9fe;
-  color: #039;
-  padding: 7px;
-  font-size: 14px;
-  width: 200px;
-}
-
-.results-section-content {
-  margin: 10px;
-  padding: 10px;
-  overflow:auto;
-}
-
-#box-table-a {
-  font-size: 12px;
-  width: 480px;
-  text-align: left;
-  border-collapse: collapse;
-}
-
-#box-table-a th {
-  padding: 6px;
-  background: #b9c9fe;
-  border-right: 1px solid #fff;
-  border-bottom: 1px solid #fff;
-  color: #039;
-  text-align: center;
-}
-
-#box-table-a td {
-  padding: 4px;
-  background: #e8edff;
-  border-bottom: 1px solid #fff;
-  border-right: 1px solid #fff;
-  color: #669;
-  border-top: 1px solid transparent;
-}
-
-#box-table-a tr:hover td {
-  background: #d0dafd;
-  color: #339;
-}
-
-    </style>
-    <script type='text/javascript' src='https://www.google.com/jsapi'></script>
-    <script type='text/javascript'>
-      google.load('visualization', '1', {packages:['corechart']});
-      google.setOnLoadCallback(init);
-      function init() {
-        switchTab('summary', 'html');
-        %s
-        switchTab('full', 'html');
-        drawTable();
-      }
-      function drawTable() {
-        %s
-      }
-      function switchTab(table, tab) {
-        document.getElementById(table + '-html').style.display = 'none';
-        document.getElementById(table + '-text').style.display = 'none';
-        document.getElementById(table + '-tsv').style.display = 'none';
-        document.getElementById(table + '-' + tab).style.display = 'block';
-      }
-    </script>
-  </head>
-
-  <body>
-    <div class='results-section'>
-      <div class='results-section-title'>Summary Table</div>
-      <div class='results-section-content'>
-        <div id='summary-html'>%s</div>
-        <div id='summary-text'><pre>%s</pre></div>
-        <div id='summary-tsv'><pre>%s</pre></div>
-      </div>
-      %s
-    </div>
-    %s
-    <div class='results-section'>
-      <div class='results-section-title'>Charts</div>
-      <div class='results-section-content'>%s</div>
-    </div>
-    <div class='results-section'>
-      <div class='results-section-title'>Full Table</div>
-      <div class='results-section-content'>
-        <div id='full-html'>%s</div>
-        <div id='full-text'><pre>%s</pre></div>
-        <div id='full-tsv'><pre>%s</pre></div>
-      </div>
-      %s
-    </div>
-    <div class='results-section'>
-      <div class='results-section-title'>Experiment File</div>
-      <div class='results-section-content'>
-        <pre>%s</pre>
-    </div>
-    </div>
-  </body>
-</html>
-"""
-
-  PERF_HTML = """
-    <div class='results-section'>
-      <div class='results-section-title'>Perf Table</div>
-      <div class='results-section-content'>
-        <div id='perf-html'>%s</div>
-        <div id='perf-text'><pre>%s</pre></div>
-        <div id='perf-tsv'><pre>%s</pre></div>
-      </div>
-      %s
-    </div>
-"""
-
-  def __init__(self, experiment):
-    super(HTMLResultsReport, self).__init__(experiment)
-
-  def _GetTabMenuHTML(self, table):
-    return """
-<div class='tab-menu'>
-  <a href="javascript:switchTab('%s', 'html')">HTML</a>
-  <a href="javascript:switchTab('%s', 'text')">Text</a>
-  <a href="javascript:switchTab('%s', 'tsv')">TSV</a>
-</div>""" % (table, table, table)
-
-  def GetReport(self):
-    chart_javascript = ""
-    charts = self._GetCharts(self.labels, self.benchmark_runs)
-    for chart in charts:
-      chart_javascript += chart.GetJavascript()
-    chart_divs = ""
-    for chart in charts:
-      chart_divs += chart.GetDiv()
-
-    summary_table = self.GetSummaryTables()
-    full_table = self.GetFullTables()
-    perf_table = self.GetSummaryTables(perf=True)
-    if perf_table:
-      perf_html = self.PERF_HTML % (
-          self.PrintTables(perf_table, "HTML"),
-          self.PrintTables(perf_table, "PLAIN"),
-          self.PrintTables(perf_table, "TSV"),
-          self._GetTabMenuHTML("perf")
-          )
-      perf_init = "switchTab('perf', 'html');"
-    else:
-      perf_html = ""
-      perf_init = ""
-
-    return self.HTML % (perf_init,
-                        chart_javascript,
-                        self.PrintTables(summary_table, "HTML"),
-                        self.PrintTables(summary_table, "PLAIN"),
-                        self.PrintTables(summary_table, "TSV"),
-                        self._GetTabMenuHTML("summary"),
-                        perf_html,
-                        chart_divs,
-                        self.PrintTables(full_table, "HTML"),
-                        self.PrintTables(full_table, "PLAIN"),
-                        self.PrintTables(full_table, "TSV"),
-                        self._GetTabMenuHTML("full"),
-                        self.experiment.experiment_file)
-
-  def _GetCharts(self, labels, benchmark_runs):
-    charts = []
-    ro = ResultOrganizer(benchmark_runs, labels)
-    result = ro.result
-    for item in result:
-      runs = result[item]
-      tg = TableGenerator(runs, ro.labels)
-      table = tg.GetTable()
-      columns = [Column(AmeanResult(),
-                        Format()),
-                 Column(MinResult(),
-                        Format()),
-                 Column(MaxResult(),
-                        Format())
-                ]
-      tf = TableFormatter(table, columns)
-      data_table = tf.GetCellTable()
-
-      for i in range(2, len(data_table)):
-        cur_row_data = data_table[i]
-        autotest_key = cur_row_data[0].string_value
-        title = "{0}: {1}".format(item, autotest_key.replace("/", ""))
-        chart = ColumnChart(title, 300, 200)
-        chart.AddColumn("Label", "string")
-        chart.AddColumn("Average", "number")
-        chart.AddColumn("Min", "number")
-        chart.AddColumn("Max", "number")
-        chart.AddSeries("Min", "line", "black")
-        chart.AddSeries("Max", "line", "black")
-        cur_index = 1
-        for label in ro.labels:
-          chart.AddRow([label, cur_row_data[cur_index].value,
-                        cur_row_data[cur_index + 1].value,
-                        cur_row_data[cur_index + 2].value])
-          if isinstance(cur_row_data[cur_index].value, str):
-            chart = None
-            break
-          cur_index += 3
-        if chart:
-          charts.append(chart)
-    return charts
diff --git a/v14/crosperf/results_sorter.py b/v14/crosperf/results_sorter.py
deleted file mode 100644
index 985a91fb..00000000
--- a/v14/crosperf/results_sorter.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-
-class ResultSorter(object):
-  def __init__(self, benchmark_runs):
-    self.table = {}
-    for benchmark_run in benchmark_runs:
-      benchmark_name = benchmark_run.benchmark_name
-      label_name = benchmark_run.label_name
-      if not benchmark_run.result:
-        continue
-      for autotest_key in benchmark_run.result.keyvals:
-        result_tuple = (benchmark_name, autotest_key, label_name)
-        if result_tuple not in self.table:
-          self.table[result_tuple] = []
-
-        cell = self.table[result_tuple]
-        index = benchmark_run.iteration - 1
-        while index >= len(cell):
-          cell.append(None)
-
-        result_value = benchmark_run.result.keyvals[autotest_key]
-        try:
-          result_value = float(result_value)
-        except ValueError:
-          pass
-
-        cell[index] = result_value
-
-    self.autotest_keys = {}
-    for benchmark_run in benchmark_runs:
-      benchmark_name = benchmark_run.benchmark_name
-      if benchmark_name not in self.autotest_keys:
-        self.autotest_keys[benchmark_name] = {}
-      if not benchmark_run.result:
-        continue
-      for autotest_key in benchmark_run.result.keyvals:
-        self.autotest_keys[benchmark_name][autotest_key] = True
-
-  def GetAutotestKeys(self, benchmark_name):
-    return self.autotest_keys[benchmark_name].keys()
-
-  def GetResults(self, benchmark_name, autotest_key, label_name):
-    try:
-      return self.table[(benchmark_name, autotest_key, label_name)]
-    except KeyError:
-      return []
diff --git a/v14/crosperf/run_tests.sh b/v14/crosperf/run_tests.sh
deleted file mode 100755
index 2a35cc73..00000000
--- a/v14/crosperf/run_tests.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-# Author: raymes@google.com (Raymes Khoury)
-
-export PYTHONPATH+=":.."
-for test in $(find -name \*test.py); do
-  echo RUNNING: ${test}
-  if ! ./${test} ; then
-    echo "Test Failed!"
-    exit 1
-  fi
-done
diff --git a/v14/crosperf/settings.py b/v14/crosperf/settings.py
deleted file mode 100644
index e407a143..00000000
--- a/v14/crosperf/settings.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-
-class Settings(object):
-  """Class representing settings (a set of fields) from an experiment file."""
-
-  def __init__(self, name, settings_type):
-    self.name = name
-    self.settings_type = settings_type
-    self.fields = {}
-    self.parent = None
-
-  def SetParentSettings(self, settings):
-    """Set the parent settings which these settings can inherit from."""
-    self.parent = settings
-
-  def AddField(self, field):
-    name = field.name
-    if name in self.fields:
-      raise Exception("Field %s defined previously." % name)
-    self.fields[name] = field
-
-  def SetField(self, name, value, append=False):
-    if name not in self.fields:
-      raise Exception("'%s' is not a valid field in '%s' settings"
-                      % (name, self.settings_type))
-    if append:
-      self.fields[name].Append(value)
-    else:
-      self.fields[name].Set(value)
-
-  def GetField(self, name):
-    """Get the value of a field with a given name."""
-    if name not in self.fields:
-      raise Exception("Field '%s' not a valid field in '%s' settings." %
-                      (name, self.name))
-    field = self.fields[name]
-    if not field.assigned and field.required:
-      raise Exception("Required field '%s' not defined in '%s' settings." %
-                      (name, self.name))
-    return self.fields[name].Get()
-
-  def Inherit(self):
-    """Inherit any unset values from the parent settings."""
-    for name in self.fields:
-      if (not self.fields[name].assigned and self.parent and
-          name in self.parent.fields and self.parent.fields[name].assigned):
-        self.fields[name].Set(self.parent.GetField(name), parse=False)
-
-  def Override(self, settings):
-    """Override settings with settings from a different object."""
-    for name in settings.fields:
-      if name in self.fields and settings.fields[name].assigned:
-        self.fields[name].Set(settings.GetField(name), parse=False)
-
-  def Validate(self):
-    """Check that all required fields have been set."""
-    for name in self.fields:
-      if not self.fields[name].assigned and self.fields[name].required:
-        raise Exception("Field %s is invalid." % name)
diff --git a/v14/crosperf/settings_factory.py b/v14/crosperf/settings_factory.py
deleted file mode 100644
index 924bc114..00000000
--- a/v14/crosperf/settings_factory.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-"""Setting files for global, benchmark and labels."""
-
-from field import BooleanField
-from field import FloatField
-from field import IntegerField
-from field import ListField
-from field import TextField
-from settings import Settings
-
-
-class BenchmarkSettings(Settings):
-  def __init__(self, name):
-    super(BenchmarkSettings, self).__init__(name, "benchmark")
-    self.AddField(TextField("autotest_name",
-                            description="The name of the autotest to run."
-                            "Defaults to the name of the benchmark."))
-    self.AddField(TextField("autotest_args",
-                            description="Arguments to be passed to the "
-                            "autotest."))
-    self.AddField(IntegerField("iterations", default=1,
-                               description="Number of iterations to run the "
-                               "autotest."))
-    self.AddField(FloatField("outlier_range", default=0.2,
-                             description="The percentage of highest/lowest "
-                             "values to omit when computing the average."))
-    self.AddField(BooleanField("rm_chroot_tmp", default=False,
-                               description="Whether remove the run_remote_test"
-                               "result in the chroot"))
-    self.AddField(BooleanField("key_results_only", default=True,
-                               description="Whether only show the key results"
-                               "of pyautoperf"))
-    self.AddField(TextField("perf_args", default="",
-                            description="The optional profile command. It "
-                            "enables perf commands to record perforamance "
-                            "related counters. It  must start with perf "
-                            "command record or stat followed by arguments."))
-
-
-class LabelSettings(Settings):
-  def __init__(self, name):
-    super(LabelSettings, self).__init__(name, "label")
-    self.AddField(TextField("chromeos_image", required=True,
-                            description="The path to the image to run tests "
-                            "on."))
-    self.AddField(TextField("chromeos_root",
-                            description="The path to a chromeos checkout which "
-                            "contains a src/scripts directory. Defaults to "
-                            "the chromeos checkout which contains the "
-                            "chromeos_image."))
-    self.AddField(TextField("md5sum", default="",
-                            description="The md5sum of this image"))
-    self.AddField(TextField("board", required=True, description="The target "
-                            "board for running experiments on, e.g. x86-alex."))
-    self.AddField(ListField("remote", description=
-                            "A comma-separated list of ip's of chromeos"
-                            "devices to run experiments on."))
-    self.AddField(TextField("image_args", required=False,
-                            default="",
-                            description="Extra arguments to pass to "
-                            "image_chromeos.py."))
-    self.AddField(TextField("cache_dir", default="",
-                            description="The cache dir for this image."))
-
-
-class GlobalSettings(Settings):
-  def __init__(self, name):
-    super(GlobalSettings, self).__init__(name, "global")
-    self.AddField(TextField("name",
-                            description="The name of the experiment. Just an "
-                            "identifier."))
-    self.AddField(TextField("board", description="The target "
-                            "board for running experiments on, e.g. x86-alex."))
-    self.AddField(ListField("remote",
-                            description="A comma-separated list of ip's of "
-                            "chromeos devices to run experiments on."))
-    self.AddField(BooleanField("rerun_if_failed", description="Whether to "
-                               "re-run failed autotest runs or not.",
-                               default=False))
-    self.AddField(BooleanField("rm_chroot_tmp", default=False,
-                               description="Whether remove the run_remote_test"
-                               "result in the chroot"))
-    self.AddField(ListField("email", description="Space-seperated"
-                            "list of email addresses to send email to."))
-    self.AddField(BooleanField("rerun", description="Whether to ignore the "
-                               "cache and for autotests to be re-run.",
-                               default=False))
-    self.AddField(BooleanField("same_specs", default=True,
-                               description="Ensure cached runs are run on the "
-                               "same kind of devices which are specified as a "
-                               "remote."))
-    self.AddField(BooleanField("same_machine", default=False,
-                               description="Ensure cached runs are run on the "
-                               "exact the same remote"))
-    self.AddField(IntegerField("iterations", default=1,
-                               description="Number of iterations to run all "
-                               "autotests."))
-    self.AddField(TextField("chromeos_root",
-                            description="The path to a chromeos checkout which "
-                            "contains a src/scripts directory. Defaults to "
-                            "the chromeos checkout which contains the "
-                            "chromeos_image."))
-    self.AddField(BooleanField("key_results_only", default=True,
-                               description="Whether only show the key results"
-                               "of pyautoperf"))
-    self.AddField(IntegerField("acquire_timeout", default=0,
-                               description="Number of seconds to wait for "
-                               "machine before exit if all the machines in "
-                               "the experiment file are busy. Default is 0"))
-    self.AddField(TextField("perf_args", default="",
-                            description="The optional profile command. It "
-                            "enables perf commands to record perforamance "
-                            "related counters. It must start with perf "
-                            "command record or stat followed by arguments."))
-    self.AddField(TextField("cache_dir", default="",
-                            description="The abs path of cache dir. "
-                            "Default is /home/$(whoami)/cros_scratch."))
-    self.AddField(BooleanField("no_email", default=False,
-                               description="Whether to disable the email to "
-                               "user after crosperf finishes."))
-    self.AddField(TextField("share_users", default="",
-                            description="Who's cache data you want to "
-                            "use. It accepts multiple users seperated by \",\""))
-
-
-class SettingsFactory(object):
-  """Factory class for building different types of Settings objects.
-
-  This factory is currently hardcoded to produce settings for ChromeOS
-  experiment files. The idea is that in the future, other types
-  of settings could be produced.
-  """
-
-  def GetSettings(self, name, settings_type):
-    if settings_type == "label" or not settings_type:
-      return LabelSettings(name)
-    if settings_type == "global":
-      return GlobalSettings(name)
-    if settings_type == "benchmark":
-      return BenchmarkSettings(name)
-
-    raise Exception("Invalid settings type: '%s'." % settings_type)
diff --git a/v14/crosperf/test_flag.py b/v14/crosperf/test_flag.py
deleted file mode 100644
index 613138b2..00000000
--- a/v14/crosperf/test_flag.py
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""A global variable for testing."""
-
-
-_is_test = [False]
-
-
-def SetTestMode(flag):
-  _is_test[0] = flag
-
-
-def GetTestMode():
-  return  _is_test[0]
diff --git a/v14/image_chromeos.py b/v14/image_chromeos.py
deleted file mode 100755
index d5d5f7fe..00000000
--- a/v14/image_chromeos.py
+++ /dev/null
@@ -1,320 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""Script to image a ChromeOS device.
-
-This script images a remote ChromeOS device with a specific image."
-"""
-
-__author__ = "asharif@google.com (Ahmad Sharif)"
-
-import filecmp
-import glob
-import optparse
-import os
-import re
-import shutil
-import sys
-import tempfile
-import time
-
-from utils import command_executer
-from utils import logger
-from utils import misc
-from utils.file_utils import FileUtils
-
-checksum_file = "/usr/local/osimage_checksum_file"
-lock_file = "/tmp/image_chromeos_lock/image_chromeos_lock"
-
-def Usage(parser, message):
-  print "ERROR: " + message
-  parser.print_help()
-  sys.exit(0)
-
-
-def DoImage(argv):
-  """Build ChromeOS."""
-
-  # Common initializations
-  cmd_executer = command_executer.GetCommandExecuter()
-  l = logger.GetLogger()
-
-  parser = optparse.OptionParser()
-  parser.add_option("-c", "--chromeos_root", dest="chromeos_root",
-                    help="Target directory for ChromeOS installation.")
-  parser.add_option("-r", "--remote", dest="remote",
-                    help="Target device.")
-  parser.add_option("-i", "--image", dest="image",
-                    help="Image binary file.")
-  parser.add_option("-b", "--board", dest="board",
-                    help="Target board override.")
-  parser.add_option("-f", "--force", dest="force",
-                    action="store_true",
-                    default=False,
-                    help="Force an image even if it is non-test.")
-  parser.add_option("-a",
-                    "--image_args",
-                    dest="image_args")
-
-
-  options = parser.parse_args(argv[1:])[0]
-
-  if options.chromeos_root is None:
-    Usage(parser, "--chromeos_root must be set")
-
-  if options.remote is None:
-    Usage(parser, "--remote must be set")
-
-  options.chromeos_root = os.path.expanduser(options.chromeos_root)
-
-  if options.board is None:
-    board = cmd_executer.CrosLearnBoard(options.chromeos_root, options.remote)
-  else:
-    board = options.board
-
-  if options.image is None:
-    images_dir = misc.GetImageDir(options.chromeos_root, board)
-    image = os.path.join(images_dir,
-                         "latest",
-                         "chromiumos_test_image.bin")
-    if not os.path.exists(image):
-      image = os.path.join(images_dir,
-                           "latest",
-                           "chromiumos_image.bin")
-  else:
-    image = options.image
-    image = os.path.expanduser(image)
-
-  image = os.path.realpath(image)
-
-  if not os.path.exists(image):
-    Usage(parser, "Image file: " + image + " does not exist!")
-
-  image_checksum = FileUtils().Md5File(image)
-
-  command = "cat " + checksum_file
-  retval, device_checksum, err = cmd_executer.CrosRunCommand(command,
-      return_output=True,
-      chromeos_root=options.chromeos_root,
-      machine=options.remote)
-
-  device_checksum = device_checksum.strip()
-  image_checksum = str(image_checksum)
-
-  l.LogOutput("Image checksum: " + image_checksum)
-  l.LogOutput("Device checksum: " + device_checksum)
-
-  if image_checksum != device_checksum:
-    [found, located_image] = LocateOrCopyImage(options.chromeos_root,
-                                               image,
-                                               board=board)
-
-    l.LogOutput("Checksums do not match. Re-imaging...")
-
-    is_test_image = IsImageModdedForTest(options.chromeos_root,
-                                         located_image)
-
-    if not is_test_image and not options.force:
-      logger.GetLogger().LogFatal("Have to pass --force to image a non-test "
-                                  "image!")
-
-    # If the device has /tmp mounted as noexec, image_to_live.sh can fail.
-    command = "mount -o remount,rw,exec /tmp"
-    cmd_executer.CrosRunCommand(command,
-                                chromeos_root=options.chromeos_root,
-                                machine=options.remote)
-
-    real_src_dir = os.path.join(os.path.realpath(options.chromeos_root),
-                                "src")
-    if located_image.find(real_src_dir) != 0:
-      raise Exception("Located image: %s not in chromeos_root: %s" %
-                      (located_image, options.chromeos_root))
-    chroot_image = os.path.join(
-        "..",
-        located_image[len(real_src_dir):].lstrip("/"))
-    cros_image_to_target_args = ["--remote=%s" % options.remote,
-                                 "--board=%s" % board,
-                                 "--from=%s" % os.path.dirname(chroot_image),
-                                 "--image-name=%s" %
-                                 os.path.basename(located_image)]
-
-    command = ("./bin/cros_image_to_target.py %s" %
-               " ".join(cros_image_to_target_args))
-    if options.image_args:
-      command += " %s" % options.image_args
-
-    # Workaround for crosbug.com/35684.
-    os.chmod(misc.GetChromeOSKeyFile(options.chromeos_root), 0600)
-    retval = cmd_executer.ChrootRunCommand(options.chromeos_root,
-                                           command)
-    if found == False:
-      temp_dir = os.path.dirname(located_image)
-      l.LogOutput("Deleting temp image dir: %s" % temp_dir)
-      shutil.rmtree(temp_dir)
-
-    logger.GetLogger().LogFatalIf(retval, "Image command failed")
-
-    # Unfortunately cros_image_to_target.py sometimes returns early when the
-    # machine isn't fully up yet.
-    retval = EnsureMachineUp(options.chromeos_root, options.remote)
-
-    command = "echo %s > %s && chmod -w %s" % (image_checksum, checksum_file,
-                                               checksum_file)
-    retval = cmd_executer.CrosRunCommand(command,
-                                         chromeos_root=options.chromeos_root,
-                                         machine=options.remote)
-    logger.GetLogger().LogFatalIf(retval, "Writing checksum failed.")
-
-    successfully_imaged = VerifyChromeChecksum(options.chromeos_root,
-                                               image,
-                                               options.remote)
-    logger.GetLogger().LogFatalIf(not successfully_imaged,
-                                  "Image verification failed!")
-    TryRemountPartitionAsRW(options.chromeos_root, options.remote)
-  else:
-    l.LogOutput("Checksums match. Skipping reimage")
-  return retval
-
-
-def LocateOrCopyImage(chromeos_root, image, board=None):
-  l = logger.GetLogger()
-  if board is None:
-    board_glob = "*"
-  else:
-    board_glob = board
-
-  chromeos_root_realpath = os.path.realpath(chromeos_root)
-  image = os.path.realpath(image)
-
-  if image.startswith("%s/" % chromeos_root_realpath):
-    return [True, image]
-
-  # First search within the existing build dirs for any matching files.
-  images_glob = ("%s/src/build/images/%s/*/*.bin" %
-                 (chromeos_root_realpath,
-                  board_glob))
-  images_list = glob.glob(images_glob)
-  for potential_image in images_list:
-    if filecmp.cmp(potential_image, image):
-      l.LogOutput("Found matching image %s in chromeos_root." % potential_image)
-      return [True, potential_image]
-  # We did not find an image. Copy it in the src dir and return the copied file.
-  if board is None:
-    board = ""
-  base_dir = ("%s/src/build/images/%s" %
-              (chromeos_root_realpath,
-               board))
-  if not os.path.isdir(base_dir):
-    os.makedirs(base_dir)
-  temp_dir = tempfile.mkdtemp(prefix="%s/tmp" % base_dir)
-  new_image = "%s/%s" % (temp_dir, os.path.basename(image))
-  l.LogOutput("No matching image found. Copying %s to %s" %
-              (image, new_image))
-  shutil.copyfile(image, new_image)
-  return [False, new_image]
-
-
-def GetImageMountCommand(chromeos_root, image, rootfs_mp, stateful_mp):
-  image_dir = os.path.dirname(image)
-  image_file = os.path.basename(image)
-  mount_command = ("cd %s/src/scripts &&"
-                   "./mount_gpt_image.sh --from=%s --image=%s"
-                   " --safe --read_only"
-                   " --rootfs_mountpt=%s"
-                   " --stateful_mountpt=%s" %
-                   (chromeos_root, image_dir, image_file, rootfs_mp,
-                    stateful_mp))
-  return mount_command
-
-
-def MountImage(chromeos_root, image, rootfs_mp, stateful_mp, unmount=False):
-  cmd_executer = command_executer.GetCommandExecuter()
-  command = GetImageMountCommand(chromeos_root, image, rootfs_mp, stateful_mp)
-  if unmount:
-    command = "%s --unmount" % command
-  retval = cmd_executer.RunCommand(command)
-  logger.GetLogger().LogFatalIf(retval, "Mount/unmount command failed!")
-  return retval
-
-
-def IsImageModdedForTest(chromeos_root, image):
-  rootfs_mp = tempfile.mkdtemp()
-  stateful_mp = tempfile.mkdtemp()
-  MountImage(chromeos_root, image, rootfs_mp, stateful_mp)
-  lsb_release_file = os.path.join(rootfs_mp, "etc/lsb-release")
-  lsb_release_contents = open(lsb_release_file).read()
-  is_test_image = re.search("test", lsb_release_contents, re.IGNORECASE)
-  MountImage(chromeos_root, image, rootfs_mp, stateful_mp, unmount=True)
-  return is_test_image
-
-
-def VerifyChromeChecksum(chromeos_root, image, remote):
-  cmd_executer = command_executer.GetCommandExecuter()
-  rootfs_mp = tempfile.mkdtemp()
-  stateful_mp = tempfile.mkdtemp()
-  MountImage(chromeos_root, image, rootfs_mp, stateful_mp)
-  image_chrome_checksum = FileUtils().Md5File("%s/opt/google/chrome/chrome" %
-                                              rootfs_mp)
-  MountImage(chromeos_root, image, rootfs_mp, stateful_mp, unmount=True)
-
-  command = "md5sum /opt/google/chrome/chrome"
-  [r, o, e] = cmd_executer.CrosRunCommand(command,
-                                          return_output=True,
-                                          chromeos_root=chromeos_root,
-                                          machine=remote)
-  device_chrome_checksum = o.split()[0]
-  if image_chrome_checksum.strip() == device_chrome_checksum.strip():
-    return True
-  else:
-    return False
-
-# Remount partition as writable.
-# TODO: auto-detect if an image is built using --noenable_rootfs_verification.
-def TryRemountPartitionAsRW(chromeos_root, remote):
-  l = logger.GetLogger()
-  cmd_executer = command_executer.GetCommandExecuter()
-  command = "sudo mount -o remount,rw /"
-  retval = cmd_executer.CrosRunCommand(\
-    command, chromeos_root=chromeos_root, machine=remote, terminated_timeout=10)
-  if retval:
-    ## Safely ignore.
-    l.LogWarning("Failed to remount partition as rw, "
-                 "probably the image was not built with "
-                 "\"--noenable_rootfs_verification\", "
-                 "you can safely ignore this.")
-  else:
-    l.LogOutput("Re-mounted partition as writable.")
-
-
-def EnsureMachineUp(chromeos_root, remote):
-  l = logger.GetLogger()
-  cmd_executer = command_executer.GetCommandExecuter()
-  timeout = 600
-  magic = "abcdefghijklmnopqrstuvwxyz"
-  command = "echo %s" % magic
-  start_time = time.time()
-  while True:
-    current_time = time.time()
-    if current_time - start_time > timeout:
-      l.LogError("Timeout of %ss reached. Machine still not up. Aborting." %
-                 timeout)
-      return False
-    retval = cmd_executer.CrosRunCommand(command,
-                                         chromeos_root=chromeos_root,
-                                         machine=remote)
-    if not retval:
-      return True
-
-
-def Main(argv):
-  misc.AcquireLock(lock_file)
-  try:
-    return DoImage(argv)
-  finally:
-    misc.ReleaseLock(lock_file)
-
-
-if __name__ == "__main__":
-  retval = Main(sys.argv)
-  sys.exit(retval)
diff --git a/v14/utils/__init__.py b/v14/utils/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/v14/utils/__init__.py
+++ /dev/null
diff --git a/v14/utils/colortrans.py b/v14/utils/colortrans.py
deleted file mode 100644
index 37e91572..00000000
--- a/v14/utils/colortrans.py
+++ /dev/null
@@ -1,376 +0,0 @@
-#! /usr/bin/env python
-
-""" Convert values between RGB hex codes and xterm-256 color codes.
-
-Nice long listing of all 256 colors and their codes. Useful for
-developing console color themes, or even script output schemes.
-
-Resources:
-* http://en.wikipedia.org/wiki/8-bit_color
-* http://en.wikipedia.org/wiki/ANSI_escape_code
-* /usr/share/X11/rgb.txt
-
-I'm not sure where this script was inspired from. I think I must have
-written it from scratch, though it's been several years now.
-"""
-
-__author__    = 'Micah Elliott http://MicahElliott.com'
-__version__   = '0.1'
-__copyright__ = 'Copyright (C) 2011 Micah Elliott.  All rights reserved.'
-__license__   = 'WTFPL http://sam.zoy.org/wtfpl/'
-
-#---------------------------------------------------------------------
-
-import sys, re
-
-CLUT = [  # color look-up table
-#    8-bit, RGB hex
-
-    # Primary 3-bit (8 colors). Unique representation!
-    ('00',  '000000'),
-    ('01',  '800000'),
-    ('02',  '008000'),
-    ('03',  '808000'),
-    ('04',  '000080'),
-    ('05',  '800080'),
-    ('06',  '008080'),
-    ('07',  'c0c0c0'),
-
-    # Equivalent "bright" versions of original 8 colors.
-    ('08',  '808080'),
-    ('09',  'ff0000'),
-    ('10',  '00ff00'),
-    ('11',  'ffff00'),
-    ('12',  '0000ff'),
-    ('13',  'ff00ff'),
-    ('14',  '00ffff'),
-    ('15',  'ffffff'),
-
-    # Strictly ascending.
-    ('16',  '000000'),
-    ('17',  '00005f'),
-    ('18',  '000087'),
-    ('19',  '0000af'),
-    ('20',  '0000d7'),
-    ('21',  '0000ff'),
-    ('22',  '005f00'),
-    ('23',  '005f5f'),
-    ('24',  '005f87'),
-    ('25',  '005faf'),
-    ('26',  '005fd7'),
-    ('27',  '005fff'),
-    ('28',  '008700'),
-    ('29',  '00875f'),
-    ('30',  '008787'),
-    ('31',  '0087af'),
-    ('32',  '0087d7'),
-    ('33',  '0087ff'),
-    ('34',  '00af00'),
-    ('35',  '00af5f'),
-    ('36',  '00af87'),
-    ('37',  '00afaf'),
-    ('38',  '00afd7'),
-    ('39',  '00afff'),
-    ('40',  '00d700'),
-    ('41',  '00d75f'),
-    ('42',  '00d787'),
-    ('43',  '00d7af'),
-    ('44',  '00d7d7'),
-    ('45',  '00d7ff'),
-    ('46',  '00ff00'),
-    ('47',  '00ff5f'),
-    ('48',  '00ff87'),
-    ('49',  '00ffaf'),
-    ('50',  '00ffd7'),
-    ('51',  '00ffff'),
-    ('52',  '5f0000'),
-    ('53',  '5f005f'),
-    ('54',  '5f0087'),
-    ('55',  '5f00af'),
-    ('56',  '5f00d7'),
-    ('57',  '5f00ff'),
-    ('58',  '5f5f00'),
-    ('59',  '5f5f5f'),
-    ('60',  '5f5f87'),
-    ('61',  '5f5faf'),
-    ('62',  '5f5fd7'),
-    ('63',  '5f5fff'),
-    ('64',  '5f8700'),
-    ('65',  '5f875f'),
-    ('66',  '5f8787'),
-    ('67',  '5f87af'),
-    ('68',  '5f87d7'),
-    ('69',  '5f87ff'),
-    ('70',  '5faf00'),
-    ('71',  '5faf5f'),
-    ('72',  '5faf87'),
-    ('73',  '5fafaf'),
-    ('74',  '5fafd7'),
-    ('75',  '5fafff'),
-    ('76',  '5fd700'),
-    ('77',  '5fd75f'),
-    ('78',  '5fd787'),
-    ('79',  '5fd7af'),
-    ('80',  '5fd7d7'),
-    ('81',  '5fd7ff'),
-    ('82',  '5fff00'),
-    ('83',  '5fff5f'),
-    ('84',  '5fff87'),
-    ('85',  '5fffaf'),
-    ('86',  '5fffd7'),
-    ('87',  '5fffff'),
-    ('88',  '870000'),
-    ('89',  '87005f'),
-    ('90',  '870087'),
-    ('91',  '8700af'),
-    ('92',  '8700d7'),
-    ('93',  '8700ff'),
-    ('94',  '875f00'),
-    ('95',  '875f5f'),
-    ('96',  '875f87'),
-    ('97',  '875faf'),
-    ('98',  '875fd7'),
-    ('99',  '875fff'),
-    ('100', '878700'),
-    ('101', '87875f'),
-    ('102', '878787'),
-    ('103', '8787af'),
-    ('104', '8787d7'),
-    ('105', '8787ff'),
-    ('106', '87af00'),
-    ('107', '87af5f'),
-    ('108', '87af87'),
-    ('109', '87afaf'),
-    ('110', '87afd7'),
-    ('111', '87afff'),
-    ('112', '87d700'),
-    ('113', '87d75f'),
-    ('114', '87d787'),
-    ('115', '87d7af'),
-    ('116', '87d7d7'),
-    ('117', '87d7ff'),
-    ('118', '87ff00'),
-    ('119', '87ff5f'),
-    ('120', '87ff87'),
-    ('121', '87ffaf'),
-    ('122', '87ffd7'),
-    ('123', '87ffff'),
-    ('124', 'af0000'),
-    ('125', 'af005f'),
-    ('126', 'af0087'),
-    ('127', 'af00af'),
-    ('128', 'af00d7'),
-    ('129', 'af00ff'),
-    ('130', 'af5f00'),
-    ('131', 'af5f5f'),
-    ('132', 'af5f87'),
-    ('133', 'af5faf'),
-    ('134', 'af5fd7'),
-    ('135', 'af5fff'),
-    ('136', 'af8700'),
-    ('137', 'af875f'),
-    ('138', 'af8787'),
-    ('139', 'af87af'),
-    ('140', 'af87d7'),
-    ('141', 'af87ff'),
-    ('142', 'afaf00'),
-    ('143', 'afaf5f'),
-    ('144', 'afaf87'),
-    ('145', 'afafaf'),
-    ('146', 'afafd7'),
-    ('147', 'afafff'),
-    ('148', 'afd700'),
-    ('149', 'afd75f'),
-    ('150', 'afd787'),
-    ('151', 'afd7af'),
-    ('152', 'afd7d7'),
-    ('153', 'afd7ff'),
-    ('154', 'afff00'),
-    ('155', 'afff5f'),
-    ('156', 'afff87'),
-    ('157', 'afffaf'),
-    ('158', 'afffd7'),
-    ('159', 'afffff'),
-    ('160', 'd70000'),
-    ('161', 'd7005f'),
-    ('162', 'd70087'),
-    ('163', 'd700af'),
-    ('164', 'd700d7'),
-    ('165', 'd700ff'),
-    ('166', 'd75f00'),
-    ('167', 'd75f5f'),
-    ('168', 'd75f87'),
-    ('169', 'd75faf'),
-    ('170', 'd75fd7'),
-    ('171', 'd75fff'),
-    ('172', 'd78700'),
-    ('173', 'd7875f'),
-    ('174', 'd78787'),
-    ('175', 'd787af'),
-    ('176', 'd787d7'),
-    ('177', 'd787ff'),
-    ('178', 'd7af00'),
-    ('179', 'd7af5f'),
-    ('180', 'd7af87'),
-    ('181', 'd7afaf'),
-    ('182', 'd7afd7'),
-    ('183', 'd7afff'),
-    ('184', 'd7d700'),
-    ('185', 'd7d75f'),
-    ('186', 'd7d787'),
-    ('187', 'd7d7af'),
-    ('188', 'd7d7d7'),
-    ('189', 'd7d7ff'),
-    ('190', 'd7ff00'),
-    ('191', 'd7ff5f'),
-    ('192', 'd7ff87'),
-    ('193', 'd7ffaf'),
-    ('194', 'd7ffd7'),
-    ('195', 'd7ffff'),
-    ('196', 'ff0000'),
-    ('197', 'ff005f'),
-    ('198', 'ff0087'),
-    ('199', 'ff00af'),
-    ('200', 'ff00d7'),
-    ('201', 'ff00ff'),
-    ('202', 'ff5f00'),
-    ('203', 'ff5f5f'),
-    ('204', 'ff5f87'),
-    ('205', 'ff5faf'),
-    ('206', 'ff5fd7'),
-    ('207', 'ff5fff'),
-    ('208', 'ff8700'),
-    ('209', 'ff875f'),
-    ('210', 'ff8787'),
-    ('211', 'ff87af'),
-    ('212', 'ff87d7'),
-    ('213', 'ff87ff'),
-    ('214', 'ffaf00'),
-    ('215', 'ffaf5f'),
-    ('216', 'ffaf87'),
-    ('217', 'ffafaf'),
-    ('218', 'ffafd7'),
-    ('219', 'ffafff'),
-    ('220', 'ffd700'),
-    ('221', 'ffd75f'),
-    ('222', 'ffd787'),
-    ('223', 'ffd7af'),
-    ('224', 'ffd7d7'),
-    ('225', 'ffd7ff'),
-    ('226', 'ffff00'),
-    ('227', 'ffff5f'),
-    ('228', 'ffff87'),
-    ('229', 'ffffaf'),
-    ('230', 'ffffd7'),
-    ('231', 'ffffff'),
-
-    # Gray-scale range.
-    ('232', '080808'),
-    ('233', '121212'),
-    ('234', '1c1c1c'),
-    ('235', '262626'),
-    ('236', '303030'),
-    ('237', '3a3a3a'),
-    ('238', '444444'),
-    ('239', '4e4e4e'),
-    ('240', '585858'),
-    ('241', '626262'),
-    ('242', '6c6c6c'),
-    ('243', '767676'),
-    ('244', '808080'),
-    ('245', '8a8a8a'),
-    ('246', '949494'),
-    ('247', '9e9e9e'),
-    ('248', 'a8a8a8'),
-    ('249', 'b2b2b2'),
-    ('250', 'bcbcbc'),
-    ('251', 'c6c6c6'),
-    ('252', 'd0d0d0'),
-    ('253', 'dadada'),
-    ('254', 'e4e4e4'),
-    ('255', 'eeeeee'),
-]
-
-def _str2hex(hexstr):
-    return int(hexstr, 16)
-
-def _strip_hash(rgb):
-    # Strip leading `#` if exists.
-    if rgb.startswith('#'):
-        rgb = rgb.lstrip('#')
-    return rgb
-
-def _create_dicts():
-    short2rgb_dict = dict(CLUT)
-    rgb2short_dict = {}
-    for k, v in short2rgb_dict.items():
-        rgb2short_dict[v] = k
-    return rgb2short_dict, short2rgb_dict
-
-def short2rgb(short):
-    return SHORT2RGB_DICT[short]
-
-def print_all():
-    """ Print all 256 xterm color codes.
-    """
-    for short, rgb in CLUT:
-        sys.stdout.write('\033[48;5;%sm%s:%s' % (short, short, rgb))
-        sys.stdout.write("\033[0m  ")
-        sys.stdout.write('\033[38;5;%sm%s:%s' % (short, short, rgb))
-        sys.stdout.write("\033[0m\n")
-    print "Printed all codes."
-    print "You can translate a hex or 0-255 code by providing an argument."
-
-def rgb2short(rgb):
-    """ Find the closest xterm-256 approximation to the given RGB value.
-    @param rgb: Hex code representing an RGB value, eg, 'abcdef'
-    @returns: String between 0 and 255, compatible with xterm.
-    >>> rgb2short('123456')
-    ('23', '005f5f')
-    >>> rgb2short('ffffff')
-    ('231', 'ffffff')
-    >>> rgb2short('0DADD6') # vimeo logo
-    ('38', '00afd7')
-    """
-    rgb = _strip_hash(rgb)
-    incs = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff)
-    # Break 6-char RGB code into 3 integer vals.
-    parts = [ int(h, 16) for h in re.split(r'(..)(..)(..)', rgb)[1:4] ]
-    res = []
-    for part in parts:
-        i = 0
-        while i < len(incs)-1:
-            s, b = incs[i], incs[i+1]  # smaller, bigger
-            if s <= part <= b:
-                s1 = abs(s - part)
-                b1 = abs(b - part)
-                if s1 < b1: closest = s
-                else: closest = b
-                res.append(closest)
-                break
-            i += 1
-    #print '***', res
-    res = ''.join([ ('%02.x' % i) for i in res ])
-    equiv = RGB2SHORT_DICT[ res ]
-    #print '***', res, equiv
-    return equiv, res
-
-RGB2SHORT_DICT, SHORT2RGB_DICT = _create_dicts()
-
-#---------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
-    if len(sys.argv) == 1:
-        print_all()
-        raise SystemExit
-    arg = sys.argv[1]
-    if len(arg) < 4 and int(arg) < 256:
-        rgb = short2rgb(arg)
-        sys.stdout.write('xterm color \033[38;5;%sm%s\033[0m -> RGB exact \033[38;5;%sm%s\033[0m' % (arg, arg, arg, rgb))
-        sys.stdout.write("\033[0m\n")
-    else:
-        short, rgb = rgb2short(arg)
-        sys.stdout.write('RGB %s -> xterm color approx \033[38;5;%sm%s (%s)' % (arg, short, short, rgb))
-        sys.stdout.write("\033[0m\n")
diff --git a/v14/utils/command_executer.py b/v14/utils/command_executer.py
deleted file mode 100644
index 0aedc47c..00000000
--- a/v14/utils/command_executer.py
+++ /dev/null
@@ -1,338 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-
-import getpass
-import os
-import pty
-import re
-import select
-import subprocess
-import tempfile
-import time
-
-import logger
-import misc
-
-mock_default = False
-
-
-def InitCommandExecuter(mock=False):
-  global mock_default
-  # Whether to default to a mock command executer or not
-  mock_default = mock
-
-
-def GetCommandExecuter(logger_to_set=None, mock=False):
-  # If the default is a mock executer, always return one.
-  if mock_default or mock:
-    return MockCommandExecuter(logger_to_set)
-  else:
-    return CommandExecuter(logger_to_set)
-
-
-class CommandExecuter:
-  def __init__(self, logger_to_set=None):
-    if logger_to_set is not None:
-      self.logger = logger_to_set
-    else:
-      self.logger = logger.GetLogger()
-
-  def RunCommand(self, cmd, return_output=False, machine=None,
-                 username=None, command_terminator=None,
-                 command_timeout=None,
-                 terminated_timeout=10,
-                 print_to_console=True):
-    """Run a command."""
-
-    cmd = str(cmd)
-
-    self.logger.LogCmd(cmd, machine, username, print_to_console)
-    if command_terminator and command_terminator.IsTerminated():
-      self.logger.LogError("Command was terminated!", print_to_console)
-      if return_output:
-        return [1, "", ""]
-      else:
-        return 1
-
-    if machine is not None:
-      user = ""
-      if username is not None:
-        user = username + "@"
-      cmd = "ssh -t -t %s%s -- '%s'" % (user, machine, cmd)
-
-    pty_fds = pty.openpty()
-    p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE,
-                         stdin=pty_fds[0], shell=True)
-
-    full_stdout = ""
-    full_stderr = ""
-
-    # Pull output from pipes, send it to file/stdout/string
-    out = err = None
-    pipes = [p.stdout, p.stderr]
-
-    my_poll = select.poll()
-    my_poll.register(p.stdout, select.POLLIN)
-    my_poll.register(p.stderr, select.POLLIN)
-
-    terminated_time = None
-    started_time = time.time()
-
-    while len(pipes):
-      if command_terminator and command_terminator.IsTerminated():
-        self.RunCommand("sudo kill -9 " + str(p.pid),
-                        print_to_console=print_to_console)
-        wait = p.wait()
-        self.logger.LogError("Command was terminated!", print_to_console)
-        if return_output:
-          return (p.wait, full_stdout, full_stderr)
-        else:
-          return wait
-
-      l=my_poll.poll(100)
-      for (fd, evt) in l:
-        if fd == p.stdout.fileno():
-          out = os.read(p.stdout.fileno(), 16384)
-          if return_output:
-            full_stdout += out
-          self.logger.LogCommandOutput(out, print_to_console)
-          if out == "":
-            pipes.remove(p.stdout)
-            my_poll.unregister(p.stdout)
-        if fd == p.stderr.fileno():
-          err = os.read(p.stderr.fileno(), 16384)
-          if return_output:
-            full_stderr += err
-          self.logger.LogCommandError(err, print_to_console)
-          if err == "":
-            pipes.remove(p.stderr)
-            my_poll.unregister(p.stderr)
-
-      if p.poll() is not None:
-        if terminated_time is None:
-          terminated_time = time.time()
-        elif (terminated_timeout is not None and
-              time.time() - terminated_time > terminated_timeout):
-          m = ("Timeout of %s seconds reached since process termination."
-               % terminated_timeout)
-          self.logger.LogWarning(m, print_to_console)
-          break
-
-      if (command_timeout is not None and
-          time.time() - started_time > command_timeout):
-        m = ("Timeout of %s seconds reached since process started."
-             % command_timeout)
-        self.logger.LogWarning(m, print_to_console)
-        self.RunCommand("kill %d || sudo kill %d || sudo kill -9 %d" %
-                        (p.pid, p.pid, p.pid),
-                        print_to_console=print_to_console)
-        break
-
-      if out == err == "":
-        break
-
-    p.wait()
-    os.close(pty_fds[0])
-    os.close(pty_fds[1])
-    if return_output:
-      return (p.returncode, full_stdout, full_stderr)
-    return p.returncode
-
-  def RemoteAccessInitCommand(self, chromeos_root, machine):
-    command = ""
-    command += "\nset -- --remote=" + machine
-    command += "\n. " + chromeos_root + "/src/scripts/common.sh"
-    command += "\n. " + chromeos_root + "/src/scripts/remote_access.sh"
-    command += "\nTMP=$(mktemp -d)"
-    command += "\nFLAGS \"$@\" || exit 1"
-    command += "\nremote_access_init"
-    return command
-
-  def WriteToTempShFile(self, contents):
-    handle, command_file = tempfile.mkstemp(prefix=os.uname()[1],
-                                            suffix=".sh")
-    os.write(handle, "#!/bin/bash\n")
-    os.write(handle, contents)
-    os.close(handle)
-    return command_file
-
-
-  def CrosLearnBoard(self, chromeos_root, machine):
-    command = self.RemoteAccessInitCommand(chromeos_root, machine)
-    command += "\nlearn_board"
-    command += "\necho ${FLAGS_board}"
-    retval, output, err = self.RunCommand(command, True)
-    self.logger.LogFatalIf(retval, "learn_board command failed")
-    return output.split()[-1]
-
-  def CrosRunCommand(self, cmd, return_output=False, machine=None,
-      username=None, command_terminator=None, chromeos_root=None,
-                     command_timeout=None,
-                     terminated_timeout=10,
-                     print_to_console=True):
-    """Run a command on a chromeos box"""
-    self.logger.LogCmd(cmd, print_to_console)
-    self.logger.LogFatalIf(not machine, "No machine provided!")
-    self.logger.LogFatalIf(not chromeos_root, "chromeos_root not given!")
-    chromeos_root = os.path.expanduser(chromeos_root)
-
-    # Write all commands to a file.
-    command_file = self.WriteToTempShFile(cmd)
-    retval = self.CopyFiles(command_file, command_file,
-                            dest_machine=machine,
-                            command_terminator=command_terminator,
-                            chromeos_root=chromeos_root,
-                            dest_cros=True,
-                            recursive=False,
-                            print_to_console=print_to_console)
-    if retval:
-      self.logger.LogError("Could not run remote command on machine."
-                           " Is the machine up?")
-      return retval
-
-    command = self.RemoteAccessInitCommand(chromeos_root, machine)
-    command += "\nremote_sh bash %s" % command_file
-    command += "\necho \"$REMOTE_OUT\""
-    retval = self.RunCommand(command, return_output,
-                             command_terminator=command_terminator,
-                             command_timeout=command_timeout,
-                             terminated_timeout=terminated_timeout,
-                             print_to_console=print_to_console)
-    if return_output:
-      connect_signature = ("Initiating first contact with remote host\n" +
-                           "Connection OK\n")
-      connect_signature_re = re.compile(connect_signature)
-      modded_return = []
-      for r in retval:
-        modded_return.append(r)
-      modded_return[1] = connect_signature_re.sub("", modded_return[1])
-      return modded_return
-    return retval
-
-  def ChrootRunCommand(self, chromeos_root, command, return_output=False,
-                       command_terminator=None, command_timeout=None,
-                       terminated_timeout=10,
-                       print_to_console=True,
-                       cros_sdk_options=""):
-    self.logger.LogCmd(command, print_to_console)
-
-    handle, command_file = tempfile.mkstemp(dir=os.path.join(chromeos_root,
-                                                           "src/scripts"),
-                                          suffix=".sh",
-                                          prefix="in_chroot_cmd")
-    os.write(handle, "#!/bin/bash\n")
-    os.write(handle, command)
-    os.close(handle)
-
-    os.chmod(command_file, 0777)
-
-    command = "cd %s; cros_sdk %s -- ./%s" % (chromeos_root, cros_sdk_options,
-                                              os.path.basename(command_file))
-    ret = self.RunCommand(command, return_output,
-                          command_terminator=command_terminator,
-                          command_timeout=command_timeout,
-                          terminated_timeout=terminated_timeout,
-                          print_to_console=print_to_console)
-    os.remove(command_file)
-    return ret
-
-
-  def RunCommands(self, cmdlist, return_output=False, machine=None,
-                  username=None, command_terminator=None):
-    cmd = " ;\n" .join(cmdlist)
-    return self.RunCommand(cmd, return_output, machine, username,
-                           command_terminator)
-
-  def CopyFiles(self, src, dest, src_machine=None, dest_machine=None,
-                src_user=None, dest_user=None, recursive=True,
-                command_terminator=None,
-                chromeos_root=None, src_cros=False, dest_cros=False,
-                print_to_console=True):
-    src = os.path.expanduser(src)
-    dest = os.path.expanduser(dest)
-
-    if recursive:
-      src = src + "/"
-      dest = dest + "/"
-
-    if src_cros == True or dest_cros == True:
-      self.logger.LogFatalIf(not (src_cros ^ dest_cros), "Only one of src_cros "
-                             "and desc_cros can be non-null.")
-      self.logger.LogFatalIf(not chromeos_root, "chromeos_root not given!")
-      if src_cros == True:
-        cros_machine = src_machine
-      else:
-        cros_machine = dest_machine
-
-      command = self.RemoteAccessInitCommand(chromeos_root, cros_machine)
-      src_parent, src_child = misc.GetRoot(src)
-      dest_parent, dest_child = misc.GetRoot(dest)
-      ssh_command = ("ssh -p ${FLAGS_ssh_port}" +
-                     " -o StrictHostKeyChecking=no" +
-                     " -o UserKnownHostsFile=$(mktemp)" +
-                     " -i $TMP_PRIVATE_KEY")
-      rsync_prefix = "\nrsync -r -e \"%s\" " % ssh_command
-      if dest_cros == True:
-        command += rsync_prefix + "%s root@%s:%s" % (src, dest_machine, dest)
-        return self.RunCommand(command,
-                               machine=src_machine,
-                               username=src_user,
-                               command_terminator=command_terminator,
-                               print_to_console=print_to_console)
-      else:
-        command += rsync_prefix + "root@%s:%s %s" % (src_machine, src, dest)
-        return self.RunCommand(command,
-                               machine=dest_machine,
-                               username=dest_user,
-                               command_terminator=command_terminator,
-                               print_to_console=print_to_console)
-
-
-    if dest_machine == src_machine:
-      command = ("rsync -a %s %s" %
-                     (src,
-                      dest))
-    else:
-      if src_machine is None:
-        src_machine = os.uname()[1]
-        src_user = getpass.getuser()
-      command = ("rsync -a %s@%s:%s %s" %
-                     (src_user, src_machine, src,
-                      dest))
-    return self.RunCommand(command,
-                           machine=dest_machine,
-                           username=dest_user,
-                           command_terminator=command_terminator,
-                           print_to_console=print_to_console)
-
-
-class MockCommandExecuter(CommandExecuter):
-  def __init__(self, logger_to_set=None):
-    if logger is not None:
-      self.logger = logger_to_set
-    else:
-      self.logger = logger.GetLogger()
-
-  def RunCommand(self, cmd, return_output=False, machine=None, username=None,
-                 command_terminator=None):
-    cmd = str(cmd)
-    if machine is None:
-      machine = "localhost"
-    if username is None:
-      username = "current"
-    logger.GetLogger().LogCmd("(Mock) " + cmd, machine, username)
-    return 0
-
-
-class CommandTerminator:
-  def __init__(self):
-    self.terminated = False
-
-  def Terminate(self):
-    self.terminated = True
-
-  def IsTerminated(self):
-    return self.terminated
diff --git a/v14/utils/constants.py b/v14/utils/constants.py
deleted file mode 100644
index 33875d66..00000000
--- a/v14/utils/constants.py
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/python2.6
-#
-# Copyright 2010 Google Inc. All Rights Reserved.
-
-"""Generic constants used accross modules.
-"""
-
-__author__ = "shenhan@google.com (Han Shen)"
-
-mounted_toolchain_root='/usr/local/toolchain_root'
diff --git a/v14/utils/email_sender.py b/v14/utils/email_sender.py
deleted file mode 100644
index f8c0d62c..00000000
--- a/v14/utils/email_sender.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-from email import Encoders
-from email.MIMEBase import MIMEBase
-from email.MIMEMultipart import MIMEMultipart
-from email.MIMEText import MIMEText
-import getpass
-import os
-import smtplib
-import sys
-
-
-class EmailSender(object):
-  class Attachment(object):
-    def __init__(self, name, content):
-      self.name = name
-      self.content = content
-
-  def SendEmail(self,
-                email_to,
-                subject,
-                text_to_send,
-                email_cc=None,
-                email_bcc=None,
-                email_from=None,
-                msg_type="plain",
-                attachments=None):
-    # Email summary to the current user.
-    msg = MIMEMultipart()
-
-    if not email_from:
-      email_from = os.path.basename(__file__)
-
-    msg["To"] = ",".join(email_to)
-    msg["Subject"] = subject
-
-    if email_from:
-      msg["From"] = email_from
-    if email_cc:
-      msg["CC"] = ",".join(email_cc)
-      email_to += email_cc
-    if email_bcc:
-      msg["BCC"] = ",".join(email_bcc)
-      email_to += email_bcc
-
-    msg.attach(MIMEText(text_to_send, msg_type))
-    if attachments:
-      for attachment in attachments:
-        part = MIMEBase("application", "octet-stream")
-        part.set_payload(attachment.content)
-        Encoders.encode_base64(part)
-        part.add_header("Content-Disposition", "attachment; filename=\"%s\"" %
-                        attachment.name)
-        msg.attach(part)
-
-    # Send the message via our own SMTP server, but don't include the
-    # envelope header.
-    s = smtplib.SMTP("localhost")
-    s.sendmail(email_from, email_to, msg.as_string())
-    s.quit()
diff --git a/v14/utils/file_utils.py b/v14/utils/file_utils.py
deleted file mode 100644
index 24809333..00000000
--- a/v14/utils/file_utils.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-import errno
-import hashlib
-import os
-import shutil
-import command_executer
-
-
-class FileUtils(object):
-  """Utilities for operations on files."""
-  _instance = None
-  DRY_RUN = False
-
-  @classmethod
-  def Configure(cls, dry_run):
-    cls.DRY_RUN = dry_run
-
-  def __new__(cls, *args, **kwargs):
-    if not cls._instance:
-      if cls.DRY_RUN:
-        cls._instance = super(FileUtils, cls).__new__(MockFileUtils, *args,
-                                                      **kwargs)
-      else:
-        cls._instance = super(FileUtils, cls).__new__(cls, *args,
-                                                      **kwargs)
-    return cls._instance
-
-  def Md5File(self, filename, block_size=2 ** 10):
-    command = "md5sum %s" % filename
-    ce = command_executer.GetCommandExecuter()
-    ret, out, err = ce.RunCommand(command, return_output=True)
-    if ret:
-      raise Exception("Could not run md5sum on: %s" % filename)
-
-    return out.strip().split()[0]
-
-  def CanonicalizeChromeOSRoot(self, chromeos_root):
-    chromeos_root = os.path.expanduser(chromeos_root)
-    if os.path.isfile(os.path.join(chromeos_root,
-                                   "src/scripts/run_remote_tests.sh")):
-      return chromeos_root
-    else:
-      return None
-
-  def ChromeOSRootFromImage(self, chromeos_image):
-    chromeos_root = os.path.join(os.path.dirname(chromeos_image),
-                                 "../../../../..")
-    return self.CanonicalizeChromeOSRoot(chromeos_root)
-
-  def MkDirP(self, path):
-    try:
-      os.makedirs(path)
-    except OSError as exc:
-      if exc.errno == errno.EEXIST:
-        pass
-      else:
-        raise
-
-  def RmDir(self, path):
-    shutil.rmtree(path, ignore_errors=True)
-
-  def WriteFile(self, path, contents):
-    with open(path, "wb") as f:
-      f.write(contents)
-
-
-class MockFileUtils(FileUtils):
-  """Mock class for file utilities."""
-
-  def Md5File(self, filename, block_size=2 ** 10):
-    return "d41d8cd98f00b204e9800998ecf8427e"
-
-  def CanonicalizeChromeOSRoot(self, chromeos_root):
-    return "/tmp/chromeos_root"
-
-  def ChromeOSRootFromImage(self, chromeos_image):
-    return "/tmp/chromeos_root"
-
-  def RmDir(self, path):
-    pass
-
-  def MkDirP(self, path):
-    pass
-
-  def WriteFile(self, path, contents):
-    pass
diff --git a/v14/utils/html_tools.py b/v14/utils/html_tools.py
deleted file mode 100644
index c90a57b5..00000000
--- a/v14/utils/html_tools.py
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/usr/bin/python2.6
-#
-# Copyright 2010 Google Inc. All Rights Reserved.
-#
-
-
-def GetPageHeader(page_title):
-  return """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<style type="text/css">
-table
-{
-border-collapse:collapse;
-}
-table, td, th
-{
-border:1px solid black;
-}
-</style>
-<script type="text/javascript">
-function displayRow(id){
-  var row = document.getElementById("group_"+id);
-  if (row.style.display == '')  row.style.display = 'none';
-    else row.style.display = '';
-  }
-</script>
-<title>%s</title>
-</head>
-<body>
-
-""" % page_title
-
-
-def GetListHeader():
-  return "<ul>"
-
-
-def GetListItem(text):
-  return "<li>%s</li>" % text
-
-
-def GetListFooter():
-  return "</ul>"
-
-
-def GetList(items):
-  return "<ul>%s</ul>" % "".join(["<li>%s</li>" % item for item in items])
-
-
-def GetParagraph(text):
-  return "<p>%s</p>" % text
-
-
-def GetFooter():
-  return "</body>\n</html>"
-
-
-def GetHeader(text, h=1):
-  return "<h%s>%s</h%s>" % (h, text, h)
-
-
-def GetTableHeader(headers):
-  row = "".join(["<th>%s</th>" % header for header in headers])
-  return "<table><tr>%s</tr>" % row
-
-
-def GetTableFooter():
-  return "</table>"
-
-
-def FormatLineBreaks(text):
-  return text.replace("\n", "<br/>")
-
-
-def GetTableCell(text):
-  return "<td>%s</td>" % FormatLineBreaks(str(text))
-
-
-def GetTableRow(columns):
-  return "<tr>%s</tr>" % "\n".join([GetTableCell(column) for column in columns])
-
-
-def GetTable(headers, rows):
-  table = [GetTableHeader(headers)]
-  table.extend([GetTableRow(row) for row in rows])
-  table.append(GetTableFooter())
-  return "\n".join(table)
-
-
-def GetLink(link, text):
-  return "<a href='%s'>%s</a>" % (link, text)
diff --git a/v14/utils/logger.py b/v14/utils/logger.py
deleted file mode 100644
index 99c679ab..00000000
--- a/v14/utils/logger.py
+++ /dev/null
@@ -1,195 +0,0 @@
-#!/usr/bin/python2.6
-#
-# Copyright 2010 Google Inc. All Rights Reserved.
-
-# System modules
-import os.path
-import sys
-import traceback
-
-#TODO(yunlian@google.com): Use GetRoot from misc
-def GetRoot(scr_name):
-  """Break up pathname into (dir+name)."""
-  abs_path = os.path.abspath(scr_name)
-  return (os.path.dirname(abs_path), os.path.basename(abs_path))
-
-
-class Logger(object):
-  """Logging helper class."""
-
-  MAX_LOG_FILES = 10
-
-  def __init__ (self, rootdir, basefilename, print_console, subdir="logs"):
-    logdir = os.path.join(rootdir, subdir)
-    basename = os.path.join(logdir, basefilename)
-
-    try:
-      os.makedirs(logdir)
-    except OSError:
-      pass
-      # print "Warning: Logs directory '%s' already exists." % logdir
-
-    self.print_console = print_console
-
-    self._CreateLogFileHandles(basename)
-
-    self._WriteTo(self.cmdfd, " ".join(sys.argv), True)
-
-  def _AddSuffix(self, basename, suffix):
-    return "%s%s" % (basename, suffix)
-
-  def _FindSuffix(self, basename):
-    timestamps = []
-    found_suffix = None
-    for i in range(self.MAX_LOG_FILES):
-      suffix = str(i)
-      suffixed_basename = self._AddSuffix(basename, suffix)
-      cmd_file = "%s.cmd" % suffixed_basename
-      if not os.path.exists(cmd_file):
-        found_suffix = suffix
-        break
-      timestamps.append(os.stat(cmd_file).st_mtime)
-
-    if found_suffix:
-      return found_suffix
-
-    # Try to pick the oldest file with the suffix and return that one.
-    suffix = str(timestamps.index(min(timestamps)))
-    # print ("Warning: Overwriting log file: %s" %
-    #       self._AddSuffix(basename, suffix))
-    return suffix
-
-  def _CreateLogFileHandle(self, name):
-    fd = None
-    try:
-      fd = open(name, "w")
-    except IOError:
-      print "Warning: could not open %s for writing." % name
-    return fd
-
-  def _CreateLogFileHandles(self, basename):
-    suffix = self._FindSuffix(basename)
-    suffixed_basename = self._AddSuffix(basename, suffix)
-
-    self.cmdfd = self._CreateLogFileHandle("%s.cmd" % suffixed_basename)
-    self.stdout = self._CreateLogFileHandle("%s.out" % suffixed_basename)
-    self.stderr = self._CreateLogFileHandle("%s.err" % suffixed_basename)
-
-    self._CreateLogFileSymlinks(basename, suffixed_basename)
-
-  # Symlink unsuffixed basename to currently suffixed one.
-  def _CreateLogFileSymlinks(self, basename, suffixed_basename):
-    try:
-      for extension in ["cmd", "out", "err"]:
-        src_file = "%s.%s" % (os.path.basename(suffixed_basename), extension)
-        dest_file = "%s.%s" % (basename, extension)
-        if os.path.exists(dest_file):
-          os.remove(dest_file)
-        os.symlink(src_file, dest_file)
-    except Exception as ex:
-      print "Exception while creating symlinks: %s" % str(ex)
-
-  def _WriteTo(self, fd, msg, flush):
-    if fd:
-      fd.write(msg)
-      if flush:
-        fd.flush()
-
-  def _LogMsg(self, file_fd, term_fd, msg, flush=True):
-    if file_fd:
-      self._WriteTo(file_fd, msg, flush)
-    if self.print_console:
-      self._WriteTo(term_fd, msg, flush)
-
-  def _GetStdout(self, print_to_console):
-    if print_to_console:
-      return sys.stdout
-    return None
-
-  def _GetStderr(self, print_to_console):
-    if print_to_console:
-      return sys.stderr
-    return None
-
-  def LogCmd(self, cmd, machine="", user=None, print_to_console=True):
-    if user:
-      host = "%s@%s" % (user, machine)
-    else:
-      host = machine
-
-    self._LogMsg(self.cmdfd, self._GetStdout(print_to_console),
-                 "CMD (%s): %s\n" % (host, cmd))
-
-  def LogFatal(self, msg, print_to_console=True):
-    self._LogMsg(self.stderr, self._GetStderr(print_to_console),
-                 "FATAL: %s\n" % msg)
-    self._LogMsg(self.stderr, self._GetStderr(print_to_console),
-                 "\n".join(traceback.format_stack()))
-    sys.exit(1)
-
-  def LogError(self, msg, print_to_console=True):
-    self._LogMsg(self.stderr, self._GetStderr(print_to_console),
-                 "ERROR: %s\n" % msg)
-
-  def LogWarning(self, msg, print_to_console=True):
-    self._LogMsg(self.stderr, self._GetStderr(print_to_console),
-                 "WARNING: %s\n" % msg)
-
-  def LogOutput(self, msg, print_to_console=True):
-    self._LogMsg(self.stdout, self._GetStdout(print_to_console),
-                 "OUTPUT: %s\n" % msg)
-
-  def LogFatalIf(self, condition, msg):
-    if condition:
-      self.LogFatal(msg)
-
-  def LogErrorIf(self, condition, msg):
-    if condition:
-      self.LogError(msg)
-
-  def LogWarningIf(self, condition, msg):
-    if condition:
-      self.LogWarning(msg)
-
-  def LogCommandOutput(self, msg, print_to_console=True):
-    self._LogMsg(self.stdout, self._GetStdout(print_to_console),
-                 msg, flush=False)
-
-  def LogCommandError(self, msg, print_to_console=True):
-    self._LogMsg(self.stderr, self._GetStderr(print_to_console),
-                 msg, flush=False)
-
-  def Flush(self):
-    self.cmdfd.flush()
-    self.stdout.flush()
-    self.stderr.flush()
-
-main_logger = None
-
-
-def InitLogger(script_name, log_dir, print_console=True):
-  """Initialize a global logger. To be called only once."""
-  global main_logger
-  assert not main_logger, "The logger has already been initialized"
-  rootdir, basefilename = GetRoot(script_name)
-  if not log_dir:
-    log_dir = rootdir
-  main_logger = Logger(log_dir, basefilename, print_console)
-
-
-def GetLogger(log_dir=""):
-  if not main_logger:
-    InitLogger(sys.argv[0], log_dir)
-  return main_logger
-
-
-def HandleUncaughtExceptions(fun):
-  """Catches all exceptions that would go outside decorated fun scope."""
-
-  def _Interceptor(*args, **kwargs):
-    try:
-      return fun(*args, **kwargs)
-    except StandardError:
-      GetLogger().LogFatal("Uncaught exception:\n%s" % traceback.format_exc())
-
-  return _Interceptor
diff --git a/v14/utils/misc.py b/v14/utils/misc.py
deleted file mode 100644
index 175a6e07..00000000
--- a/v14/utils/misc.py
+++ /dev/null
@@ -1,327 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2010 Google Inc. All Rights Reserved.
-
-"""Utilities for toolchain build."""
-
-__author__ = "asharif@google.com (Ahmad Sharif)"
-
-from contextlib import contextmanager
-import os
-import re
-import shutil
-import sys
-import time
-
-import lock_machine
-
-import command_executer
-import logger
-
-
-def GetChromeOSVersionFromLSBVersion(lsb_version):
-  """Get Chromeos version from Lsb version."""
-  ce = command_executer.GetCommandExecuter()
-  command = "git ls-remote http://git.chromium.org/chromiumos/manifest.git"
-  ret, out, _ = ce.RunCommand(command, return_output=True,
-                              print_to_console=False)
-  assert ret == 0, "Command %s failed" % command
-  lower = []
-  for line in out.splitlines():
-    mo = re.search(r"refs/heads/release-R(\d+)-(\d+)\.B", line)
-    if mo:
-      revision = int(mo.group(1))
-      build = int(mo.group(2))
-      lsb_build = int(lsb_version.split(".")[0])
-      if lsb_build > build:
-        lower.append(revision)
-  lower = sorted(lower)
-  if lower:
-    return "R%d-%s" % (lower[-1] + 1, lsb_version)
-  else:
-    return "Unknown"
-
-
-def ApplySubs(string, *substitutions):
-  for pattern, replacement in substitutions:
-    string = re.sub(pattern, replacement, string)
-  return string
-
-
-def UnitToNumber(unit_num, base=1000):
-  """Convert a number with unit to float."""
-  unit_dict = {"kilo": base,
-               "mega": base**2,
-               "giga": base**3}
-  unit_num = unit_num.lower()
-  mo = re.search(r"(\d*)(.+)?", unit_num)
-  number = mo.group(1)
-  unit = mo.group(2)
-  if not unit:
-    return float(number)
-  for k, v in unit_dict.items():
-    if k.startswith(unit):
-      return float(number) * v
-  raise Exception("Unit: %s not found in byte: %s!" %
-                  (unit,
-                   unit_num))
-
-
-def GetFilenameFromString(string):
-  return ApplySubs(string,
-                   (r"/", "__"),
-                   (r"\s", "_"),
-                   (r"[\^\$=\"\\\?]", ""),
-                  )
-
-
-def GetRoot(scr_name):
-  """Break up pathname into (dir+name)."""
-  abs_path = os.path.abspath(scr_name)
-  return (os.path.dirname(abs_path), os.path.basename(abs_path))
-
-
-def GetChromeOSKeyFile(chromeos_root):
-  return os.path.join(chromeos_root,
-                      "src",
-                      "scripts",
-                      "mod_for_test_scripts",
-                      "ssh_keys",
-                      "testing_rsa")
-
-
-def GetChrootPath(chromeos_root):
-  return os.path.join(chromeos_root,
-                      "chroot")
-
-
-def GetInsideChrootPath(chromeos_root, file_path):
-  if not file_path.startswith(GetChrootPath(chromeos_root)):
-    raise Exception("File: %s doesn't seem to be in the chroot: %s" %
-                    (file_path,
-                     chromeos_root))
-  return file_path[len(GetChrootPath(chromeos_root)):]
-
-
-def GetOutsideChrootPath(chromeos_root, file_path):
-  return os.path.join(GetChrootPath(chromeos_root),
-                      file_path.lstrip("/"))
-
-
-def FormatQuotedCommand(command):
-  return ApplySubs(command,
-                   ("\"", "\\\""))
-
-
-def FormatCommands(commands):
-  return ApplySubs(str(commands),
-                   ("&&", "&&\n"),
-                   (";", ";\n"),
-                   (r"\n+\s*", "\n"))
-
-
-def GetImageDir(chromeos_root, board):
-  return os.path.join(chromeos_root,
-                      "src",
-                      "build",
-                      "images",
-                      board)
-
-
-def LabelLatestImage(chromeos_root, board, label):
-  image_dir = GetImageDir(chromeos_root, board)
-  latest_image_dir = os.path.join(image_dir, "latest")
-  latest_image_dir = os.path.realpath(latest_image_dir)
-  latest_image_dir = os.path.basename(latest_image_dir)
-  with WorkingDirectory(image_dir):
-    command = "ln -sf -T %s %s" % (latest_image_dir, label)
-    ce = command_executer.GetCommandExecuter()
-    return ce.RunCommand(command)
-
-
-def DoesLabelExist(chromeos_root, board, label):
-  image_label = os.path.join(GetImageDir(chromeos_root, board),
-                             label)
-  return os.path.exists(image_label)
-
-
-def GetBuildPackagesCommand(board, usepkg=False, debug=False):
-  if usepkg:
-    usepkg_flag = "--usepkg"
-  else:
-    usepkg_flag = "--nousepkg"
-  if debug:
-    withdebug_flag = '--withdebug'
-  else:
-    withdebug_flag = '--nowithdebug'
-  return ("./build_packages %s --withdev --withtest --withautotest "
-          "--skip_toolchain_update %s --board=%s" %
-          (usepkg_flag, withdebug_flag, board))
-
-
-def GetBuildImageCommand(board, dev=False):
-  dev_args = ""
-  if dev:
-    dev_args = "--noenable_rootfs_verification --disk_layout=2gb-rootfs"
-  return "./build_image --board=%s %s test" % (board, dev_args)
-
-def GetSetupBoardCommand(board, gcc_version=None, binutils_version=None,
-                         usepkg=None, force=None):
-  """Get setup_board command."""
-  options = []
-
-  if gcc_version:
-    options.append("--gcc_version=%s" % gcc_version)
-
-  if binutils_version:
-    options.append("--binutils_version=%s" % binutils_version)
-
-  if usepkg:
-    options.append("--usepkg")
-  else:
-    options.append("--nousepkg")
-
-  if force:
-    options.append("--force")
-
-  return "./setup_board --board=%s %s" % (board, " ".join(options))
-
-
-def CanonicalizePath(path):
-  path = os.path.expanduser(path)
-  path = os.path.realpath(path)
-  return path
-
-
-def GetCtargetFromBoard(board, chromeos_root):
-  """Get Ctarget from board."""
-  base_board = board.split("_")[0]
-  command = ("source "
-             "../platform/dev/toolchain_utils.sh; get_ctarget_from_board %s" %
-             base_board)
-  ce = command_executer.GetCommandExecuter()
-  ret, out, _ = ce.ChrootRunCommand(chromeos_root,
-                                    command,
-                                    return_output=True)
-  if ret != 0:
-    raise ValueError("Board %s is invalid!" % board)
-  # Remove ANSI escape sequences.
-  out = StripANSIEscapeSequences(out)
-  return out.strip()
-
-
-def StripANSIEscapeSequences(string):
-  string = re.sub(r"\x1b\[[0-9]*[a-zA-Z]", "", string)
-  return string
-
-
-def GetChromeSrcDir():
-  return "var/cache/distfiles/target/chrome-src/src"
-
-
-def GetEnvStringFromDict(env_dict):
-  return " ".join(["%s=\"%s\"" % var for var in env_dict.items()])
-
-
-def MergeEnvStringWithDict(env_string, env_dict, prepend=True):
-  """Merge env string with dict."""
-  if not env_string.strip():
-    return GetEnvStringFromDict(env_dict)
-  override_env_list = []
-  ce = command_executer.GetCommandExecuter()
-  for k, v in env_dict.items():
-    v = v.strip("\"'")
-    if prepend:
-      new_env = "%s=\"%s $%s\"" % (k, v, k)
-    else:
-      new_env = "%s=\"$%s %s\"" % (k, k, v)
-    command = "; ".join([env_string, new_env, "echo $%s" % k])
-    ret, out, _ = ce.RunCommand(command, return_output=True)
-    override_env_list.append("%s=%r" % (k, out.strip()))
-  ret = env_string + " " + " ".join(override_env_list)
-  return ret.strip()
-
-
-def GetAllImages(chromeos_root, board):
-  ce = command_executer.GetCommandExecuter()
-  command = ("find %s/src/build/images/%s -name chromiumos_test_image.bin" %
-             (chromeos_root, board))
-  ret, out, _ = ce.RunCommand(command, return_output=True)
-  assert ret == 0, "Could not run command: %s" % command
-  return out.splitlines()
-
-
-def AcquireLock(lock_file, timeout=1200):
-  """Acquire a lock with timeout."""
-  start_time = time.time()
-  locked = False
-  abs_path = os.path.abspath(lock_file)
-  dir_path = os.path.dirname(abs_path)
-  sleep_time = min(10, timeout/10.0)
-  reason = "pid: {0}, commad: {1}".format(os.getpid(),
-                                          sys.argv[0])
-  if not os.path.exists(dir_path):
-    try:
-      with lock_machine.FileCreationMask(0002):
-        os.makedirs(dir_path)
-    except OSError:
-      print "Cannot create dir {0}, exiting...".format(dir_path)
-      exit(0)
-  while True:
-    locked = (lock_machine.Lock(lock_file).NonBlockingLock(True, reason))
-    if locked:
-      break
-    time.sleep(sleep_time)
-    if time.time() - start_time > timeout:
-      logger.GetLogger().LogWarning(
-          "Could not acquire lock on this file: {0} within {1} seconds."
-          "Manually remove the file if you think the lock is stale"
-          .format(abs_path, timeout))
-      break
-  return locked
-
-
-def ReleaseLock(lock_file):
-  lock_file = os.path.abspath(lock_file)
-  ret = lock_machine.Lock(lock_file).Unlock(True)
-  assert ret, ("Could not unlock {0},"
-               "Please remove it manually".format(lock_file))
-
-
-def IsFloat(text):
-  if text is None:
-    return False
-  try:
-    float(text)
-    return True
-  except ValueError:
-    return False
-
-def RemoveChromeBrowserObjectFiles(chromeos_root, board):
-  """ Remove any object files from all the posible locations """
-  out_dir = os.path.join(
-      GetChrootPath(chromeos_root),
-      "var/cache/chromeos-chrome/chrome-src/src/out_%s" % board)
-  if os.path.exists(out_dir):
-    shutil.rmtree(out_dir)
-    logger.GetLogger().LogCmd("rm -rf %s" % out_dir)
-  out_dir = os.path.join(
-      GetChrootPath(chromeos_root),
-      "var/cache/chromeos-chrome/chrome-src-internal/src/out_%s" % board)
-  if os.path.exists(out_dir):
-    shutil.rmtree(out_dir)
-    logger.GetLogger().LogCmd("rm -rf %s" % out_dir)
-
-@contextmanager
-def WorkingDirectory(new_dir):
-  """Get the working directory."""
-  old_dir = os.getcwd()
-  if old_dir != new_dir:
-    msg = "cd %s" % new_dir
-    logger.GetLogger().LogCmd(msg)
-  os.chdir(new_dir)
-  yield new_dir
-  if old_dir != new_dir:
-    msg = "cd %s" % old_dir
-    logger.GetLogger().LogCmd(msg)
-  os.chdir(old_dir)
diff --git a/v14/utils/misc_test.py b/v14/utils/misc_test.py
deleted file mode 100644
index e234332f..00000000
--- a/v14/utils/misc_test.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""Tests for misc."""
-
-__author__ = 'asharif@google.com (Ahmad Sharif)'
-
-# System modules
-import re
-import unittest
-
-# Local modules
-import misc
-
-
-class UtilsTest(unittest.TestCase):
-  def testGetFilenameFromString(self):
-    string = 'a /b=c"d^$?\\'
-    filename = misc.GetFilenameFromString(string)
-    self.assertTrue(filename == 'a___bcd')
-
-  def testPrependMergeEnv(self):
-    var = 'USE'
-    use_flags = 'hello 123'
-    added_use_flags = 'bla bla'
-    env_string = '%s=%r' % (var, use_flags)
-    new_env_string = misc.MergeEnvStringWithDict(env_string,
-                                                 {var: added_use_flags})
-    expected_new_env = '%s=%r' % (var, ' '.join([added_use_flags, use_flags]))
-    self.assertTrue(new_env_string == ' '.join([env_string, expected_new_env]))
-
-  def testGetChromeOSVersionFromLSBVersion(self):
-    versions_dict = {"2630.0.0": "22",
-                     "2030.0.0": "19"}
-    f = misc.GetChromeOSVersionFromLSBVersion
-    for k, v in versions_dict.items():
-      self.assertTrue(f(k) == "R%s-%s" % (v, k))
-
-  def testPostpendMergeEnv(self):
-    var = 'USE'
-    use_flags = 'hello 123'
-    added_use_flags = 'bla bla'
-    env_string = '%s=%r' % (var, use_flags)
-    new_env_string = misc.MergeEnvStringWithDict(env_string,
-                                                 {var: added_use_flags},
-                                                 False)
-    expected_new_env = '%s=%r' % (var, ' '.join([use_flags, added_use_flags]))
-    self.assertTrue(new_env_string == ' '.join([env_string, expected_new_env]))
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/v14/utils/perf_diff.py b/v14/utils/perf_diff.py
deleted file mode 100755
index d56eba16..00000000
--- a/v14/utils/perf_diff.py
+++ /dev/null
@@ -1,324 +0,0 @@
-#!/usr/bin/python
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""One-line documentation for perf_diff module.
-
-A detailed description of perf_diff.
-"""
-
-__author__ = "asharif@google.com (Ahmad Sharif)"
-
-import optparse
-import re
-import sys
-
-import misc
-import tabulator
-
-ROWS_TO_SHOW = "Rows_to_show_in_the_perf_table"
-
-def GetPerfDictFromReport(report_file):
-  output = {}
-  perf_report = PerfReport(report_file)
-  for k, v in perf_report.sections.items():
-    if k not in output:
-      output[k] = {}
-    output[k][ROWS_TO_SHOW] = 0
-    for function in v.functions:
-      out_key = "%s" % (function.name)
-      output[k][out_key] = function.count
-      if function.percent > 1:
-        output[k][ROWS_TO_SHOW] += 1
-  return output
-
-
-def _SortDictionaryByValue(d):
-  l = [(k, v) for (k, v) in d.iteritems()]
-
-  def GetFloat(x):
-    if misc.IsFloat(x):
-      return float(x)
-    else:
-      return x
-
-  sorted_l = sorted(l,
-                    key=lambda x: GetFloat(x[1]))
-  sorted_l.reverse()
-  return [f[0] for f in sorted_l]
-
-
-class Tabulator(object):
-  def __init__(self, all_dicts):
-    self._all_dicts = all_dicts
-
-  def PrintTable(self):
-    for dicts in self._all_dicts:
-      self.PrintTableHelper(dicts)
-
-  def PrintTableHelper(self, dicts):
-    """Transfrom dicts to tables."""
-    fields = {}
-    for d in dicts:
-      for f in d.keys():
-        if f not in fields:
-          fields[f] = d[f]
-        else:
-          fields[f] = max(fields[f], d[f])
-    table = []
-    header = ["name"]
-    for i in range(len(dicts)):
-      header.append(i)
-
-    table.append(header)
-
-    sorted_fields = _SortDictionaryByValue(fields)
-
-    for f in sorted_fields:
-      row = [f]
-      for d in dicts:
-        if f in d:
-          row.append(d[f])
-        else:
-          row.append("0")
-      table.append(row)
-
-    print tabulator.GetSimpleTable(table)
-
-
-class Function(object):
-  def __init__(self):
-    self.count = 0
-    self.name = ""
-    self.percent = 0
-
-
-class Section(object):
-  def __init__(self, contents):
-    self.raw_contents = contents
-    self._ParseSection()
-
-  def _ParseSection(self):
-    matches = re.findall(r"Events: (\w+)\s+(.*)", self.raw_contents)
-    assert len(matches) <= 1, "More than one event found in 1 section"
-    if not matches:
-      return
-    match = matches[0]
-    self.name = match[1]
-    self.count = misc.UnitToNumber(match[0])
-
-    self.functions = []
-    for line in self.raw_contents.splitlines():
-      if not line.strip():
-        continue
-      if "%" not in line:
-        continue
-      if not line.startswith("#"):
-        fields = [f for f in line.split(" ") if f]
-        function = Function()
-        function.percent = float(fields[0].strip("%"))
-        function.count = int(fields[1])
-        function.name = " ".join(fields[2:])
-        self.functions.append(function)
-
-
-class PerfReport(object):
-  """Get report from raw report."""
-
-  def __init__(self, perf_file):
-    self.perf_file = perf_file
-    self._ReadFile()
-    self.sections = {}
-    self.metadata = {}
-    self._section_contents = []
-    self._section_header = ""
-    self._SplitSections()
-    self._ParseSections()
-    self._ParseSectionHeader()
-
-  def _ParseSectionHeader(self):
-    """Parse a header of a perf report file."""
-    # The "captured on" field is inaccurate - this actually refers to when the
-    # report was generated, not when the data was captured.
-    for line in self._section_header.splitlines():
-      line = line[2:]
-      if ":" in line:
-        key, val = line.strip().split(":", 1)
-        key = key.strip()
-        val = val.strip()
-        self.metadata[key] = val
-
-  def _ReadFile(self):
-    self._perf_contents = open(self.perf_file).read()
-
-  def _ParseSections(self):
-    self.event_counts = {}
-    self.sections = {}
-    for section_content in self._section_contents:
-      section = Section(section_content)
-      section.name = self._GetHumanReadableName(section.name)
-      self.sections[section.name] = section
-
-  # TODO(asharif): Do this better.
-  def _GetHumanReadableName(self, section_name):
-    if not "raw" in section_name:
-      return section_name
-    raw_number = section_name.strip().split(" ")[-1]
-    for line in self._section_header.splitlines():
-      if raw_number in line:
-        name = line.strip().split(" ")[5]
-        return name
-
-  def _SplitSections(self):
-    self._section_contents = []
-    indices = [m.start() for m in re.finditer("# Events:", self._perf_contents)]
-    indices.append(len(self._perf_contents))
-    for i in range(len(indices) - 1):
-      section_content = self._perf_contents[indices[i]:indices[i+1]]
-      self._section_contents.append(section_content)
-    self._section_header = ""
-    if indices:
-      self._section_header = self._perf_contents[0:indices[0]]
-
-
-class PerfDiffer(object):
-  """Perf differ class."""
-
-  def __init__(self, reports, num_symbols, common_only):
-    self._reports = reports
-    self._num_symbols = num_symbols
-    self._common_only = common_only
-    self._common_function_names = {}
-
-  def DoDiff(self):
-    """The function that does the diff."""
-    section_names = self._FindAllSections()
-
-    filename_dicts = []
-    summary_dicts = []
-    for report in self._reports:
-      d = {}
-      filename_dicts.append({"file": report.perf_file})
-      for section_name in section_names:
-        if section_name in report.sections:
-          d[section_name] = report.sections[section_name].count
-      summary_dicts.append(d)
-
-    all_dicts = [filename_dicts, summary_dicts]
-
-    for section_name in section_names:
-      function_names = self._GetTopFunctions(section_name,
-                                             self._num_symbols)
-      self._FindCommonFunctions(section_name)
-      dicts = []
-      for report in self._reports:
-        d = {}
-        if section_name in report.sections:
-          section = report.sections[section_name]
-
-          # Get a common scaling factor for this report.
-          common_scaling_factor = self._GetCommonScalingFactor(section)
-
-          for function in section.functions:
-            if function.name in function_names:
-              key = "%s %s" % (section.name, function.name)
-              d[key] = function.count
-              # Compute a factor to scale the function count by in common_only
-              # mode.
-              if self._common_only and (
-                  function.name in self._common_function_names[section.name]):
-                d[key + " scaled"] = common_scaling_factor * function.count
-        dicts.append(d)
-
-      all_dicts.append(dicts)
-
-    mytabulator = Tabulator(all_dicts)
-    mytabulator.PrintTable()
-
-  def _FindAllSections(self):
-    sections = {}
-    for report in self._reports:
-      for section in report.sections.values():
-        if section.name not in sections:
-          sections[section.name] = section.count
-        else:
-          sections[section.name] = max(sections[section.name],
-                                       section.count)
-    return _SortDictionaryByValue(sections)
-
-  def _GetCommonScalingFactor(self, section):
-    unique_count = self._GetCount(
-        section,
-        lambda x: x in self._common_function_names[section.name])
-    return 100.0/unique_count
-
-  def _GetCount(self, section, filter_fun=None):
-    total_count = 0
-    for function in section.functions:
-      if not filter_fun or filter_fun(function.name):
-        total_count += int(function.count)
-    return total_count
-
-  def _FindCommonFunctions(self, section_name):
-    function_names_list = []
-    for report in self._reports:
-      if section_name in report.sections:
-        section = report.sections[section_name]
-        function_names = [f.name for f in section.functions]
-        function_names_list.append(function_names)
-
-    self._common_function_names[section_name] = (
-        reduce(set.intersection, map(set, function_names_list)))
-
-  def _GetTopFunctions(self, section_name, num_functions):
-    all_functions = {}
-    for report in self._reports:
-      if section_name in report.sections:
-        section = report.sections[section_name]
-        for f in section.functions[:num_functions]:
-          if f.name in all_functions:
-            all_functions[f.name] = max(all_functions[f.name], f.count)
-          else:
-            all_functions[f.name] = f.count
-    # FIXME(asharif): Don't really need to sort these...
-    return _SortDictionaryByValue(all_functions)
-
-  def _GetFunctionsDict(self, section, function_names):
-    d = {}
-    for function in section.functions:
-      if function.name in function_names:
-        d[function.name] = function.count
-    return d
-
-
-def Main(argv):
-  """The entry of the main."""
-  parser = optparse.OptionParser()
-  parser.add_option("-n",
-                    "--num_symbols",
-                    dest="num_symbols",
-                    default="5",
-                    help="The number of symbols to show.")
-  parser.add_option("-c",
-                    "--common_only",
-                    dest="common_only",
-                    action="store_true",
-                    default=False,
-                    help="Diff common symbols only.")
-
-  options, args = parser.parse_args(argv)
-
-  try:
-    reports = []
-    for report in args[1:]:
-      report = PerfReport(report)
-      reports.append(report)
-    pd = PerfDiffer(reports, int(options.num_symbols), options.common_only)
-    pd.DoDiff()
-  finally:
-    pass
-
-  return 0
-
-
-if __name__ == "__main__":
-  sys.exit(Main(sys.argv))
diff --git a/v14/utils/pstat.py b/v14/utils/pstat.py
deleted file mode 100644
index dae681e6..00000000
--- a/v14/utils/pstat.py
+++ /dev/null
@@ -1,1068 +0,0 @@
-# Copyright (c) 1999-2007 Gary Strangman; All Rights Reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Comments and/or additions are welcome (send e-mail to:
-# strang@nmr.mgh.harvard.edu).
-# 
-"""
-pstat.py module
-
-#################################################
-#######  Written by:  Gary Strangman  ###########
-#######  Last modified:  Dec 18, 2007 ###########
-#################################################
-
-This module provides some useful list and array manipulation routines
-modeled after those found in the |Stat package by Gary Perlman, plus a
-number of other useful list/file manipulation functions.  The list-based
-functions include:
-
-      abut (source,*args)
-      simpleabut (source, addon)
-      colex (listoflists,cnums)
-      collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
-      dm (listoflists,criterion)
-      flat (l)
-      linexand (listoflists,columnlist,valuelist)
-      linexor (listoflists,columnlist,valuelist)
-      linedelimited (inlist,delimiter)
-      lineincols (inlist,colsize) 
-      lineincustcols (inlist,colsizes)
-      list2string (inlist)
-      makelol(inlist)
-      makestr(x)
-      printcc (lst,extra=2)
-      printincols (listoflists,colsize)
-      pl (listoflists)
-      printl(listoflists)
-      replace (lst,oldval,newval)
-      recode (inlist,listmap,cols='all')
-      remap (listoflists,criterion)
-      roundlist (inlist,num_digits_to_round_floats_to)
-      sortby(listoflists,sortcols)
-      unique (inlist)
-      duplicates(inlist)
-      writedelimited (listoflists, delimiter, file, writetype='w')
-
-Some of these functions have alternate versions which are defined only if
-Numeric (NumPy) can be imported.  These functions are generally named as
-above, with an 'a' prefix.
-
-      aabut (source, *args)
-      acolex (a,indices,axis=1)
-      acollapse (a,keepcols,collapsecols,sterr=0,ns=0)
-      adm (a,criterion)
-      alinexand (a,columnlist,valuelist)
-      alinexor (a,columnlist,valuelist)
-      areplace (a,oldval,newval)
-      arecode (a,listmap,col='all')
-      arowcompare (row1, row2)
-      arowsame (row1, row2)
-      asortrows(a,axis=0)
-      aunique(inarray)
-      aduplicates(inarray)
-
-Currently, the code is all but completely un-optimized.  In many cases, the
-array versions of functions amount simply to aliases to built-in array
-functions/methods.  Their inclusion here is for function name consistency.
-"""
-
-## CHANGE LOG:
-## ==========
-## 07-11-26 ... edited to work with numpy
-## 01-11-15 ... changed list2string() to accept a delimiter
-## 01-06-29 ... converted exec()'s to eval()'s to make compatible with Py2.1
-## 01-05-31 ... added duplicates() and aduplicates() functions
-## 00-12-28 ... license made GPL, docstring and import requirements
-## 99-11-01 ... changed version to 0.3
-## 99-08-30 ... removed get, getstrings, put, aget, aput (into io.py)
-## 03/27/99 ... added areplace function, made replace fcn recursive
-## 12/31/98 ... added writefc function for ouput to fixed column sizes
-## 12/07/98 ... fixed import problem (failed on collapse() fcn)
-##              added __version__ variable (now 0.2)
-## 12/05/98 ... updated doc-strings
-##              added features to collapse() function
-##              added flat() function for lists
-##              fixed a broken asortrows() 
-## 11/16/98 ... fixed minor bug in aput for 1D arrays
-##
-## 11/08/98 ... fixed aput to output large arrays correctly
-
-import stats  # required 3rd party module
-import string, copy
-from types import *
-
-__version__ = 0.4
-
-###===========================  LIST FUNCTIONS  ==========================
-###
-### Here are the list functions, DEFINED FOR ALL SYSTEMS.
-### Array functions (for NumPy-enabled computers) appear below.
-###
-
-def abut (source,*args):
-    """
-Like the |Stat abut command.  It concatenates two lists side-by-side
-and returns the result.  '2D' lists are also accomodated for either argument
-(source or addon).  CAUTION:  If one list is shorter, it will be repeated
-until it is as long as the longest list.  If this behavior is not desired,
-use pstat.simpleabut().
-
-Usage:   abut(source, args)   where args=any # of lists
-Returns: a list of lists as long as the LONGEST list past, source on the
-         'left', lists in <args> attached consecutively on the 'right'
-"""
-
-    if type(source) not in [ListType,TupleType]:
-        source = [source]
-    for addon in args:
-        if type(addon) not in [ListType,TupleType]:
-            addon = [addon]
-        if len(addon) < len(source):                # is source list longer?
-            if len(source) % len(addon) == 0:        # are they integer multiples?
-                repeats = len(source)/len(addon)    # repeat addon n times
-                origadd = copy.deepcopy(addon)
-                for i in range(repeats-1):
-                    addon = addon + origadd
-            else:
-                repeats = len(source)/len(addon)+1  # repeat addon x times,
-                origadd = copy.deepcopy(addon)      #    x is NOT an integer
-                for i in range(repeats-1):
-                    addon = addon + origadd
-                    addon = addon[0:len(source)]
-        elif len(source) < len(addon):                # is addon list longer?
-            if len(addon) % len(source) == 0:        # are they integer multiples?
-                repeats = len(addon)/len(source)    # repeat source n times
-                origsour = copy.deepcopy(source)
-                for i in range(repeats-1):
-                    source = source + origsour
-            else:
-                repeats = len(addon)/len(source)+1  # repeat source x times,
-                origsour = copy.deepcopy(source)    #   x is NOT an integer
-                for i in range(repeats-1):
-                    source = source + origsour
-                source = source[0:len(addon)]
-
-        source = simpleabut(source,addon)
-    return source
-
-
-def simpleabut (source, addon):
-    """
-Concatenates two lists as columns and returns the result.  '2D' lists
-are also accomodated for either argument (source or addon).  This DOES NOT
-repeat either list to make the 2 lists of equal length.  Beware of list pairs
-with different lengths ... the resulting list will be the length of the
-FIRST list passed.
-
-Usage:   simpleabut(source,addon)  where source, addon=list (or list-of-lists)
-Returns: a list of lists as long as source, with source on the 'left' and
-                 addon on the 'right'
-"""
-    if type(source) not in [ListType,TupleType]:
-        source = [source]
-    if type(addon) not in [ListType,TupleType]:
-        addon = [addon]
-    minlen = min(len(source),len(addon))
-    list = copy.deepcopy(source)                # start abut process
-    if type(source[0]) not in [ListType,TupleType]:
-        if type(addon[0]) not in [ListType,TupleType]:
-            for i in range(minlen):
-                list[i] = [source[i]] + [addon[i]]        # source/addon = column
-        else:
-            for i in range(minlen):
-                list[i] = [source[i]] + addon[i]        # addon=list-of-lists
-    else:
-        if type(addon[0]) not in [ListType,TupleType]:
-            for i in range(minlen):
-                list[i] = source[i] + [addon[i]]        # source=list-of-lists
-        else:
-            for i in range(minlen):
-                list[i] = source[i] + addon[i]        # source/addon = list-of-lists
-    source = list
-    return source
-
-
-def colex (listoflists,cnums):
-    """
-Extracts from listoflists the columns specified in the list 'cnums'
-(cnums can be an integer, a sequence of integers, or a string-expression that
-corresponds to a slice operation on the variable x ... e.g., 'x[3:]' will colex
-columns 3 onward from the listoflists).
-
-Usage:   colex (listoflists,cnums)
-Returns: a list-of-lists corresponding to the columns from listoflists
-         specified by cnums, in the order the column numbers appear in cnums
-"""
-    global index
-    column = 0
-    if type(cnums) in [ListType,TupleType]:   # if multiple columns to get
-        index = cnums[0]
-        column = map(lambda x: x[index], listoflists)
-        for col in cnums[1:]:
-            index = col
-            column = abut(column,map(lambda x: x[index], listoflists))
-    elif type(cnums) == StringType:              # if an 'x[3:]' type expr.
-        evalstring = 'map(lambda x: x'+cnums+', listoflists)'
-        column = eval(evalstring)
-    else:                                     # else it's just 1 col to get
-        index = cnums
-        column = map(lambda x: x[index], listoflists)
-    return column
-
-
-def collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None):
-     """
-Averages data in collapsecol, keeping all unique items in keepcols
-(using unique, which keeps unique LISTS of column numbers), retaining the
-unique sets of values in keepcols, the mean for each.  Setting fcn1
-and/or fcn2 to point to a function rather than None (e.g., stats.sterr, len)
-will append those results (e.g., the sterr, N) after each calculated mean.
-cfcn is the collapse function to apply (defaults to mean, defined here in the
-pstat module to avoid circular imports with stats.py, but harmonicmean or
-others could be passed).
-
-Usage:    collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
-Returns: a list of lists with all unique permutations of entries appearing in
-     columns ("conditions") specified by keepcols, abutted with the result of
-     cfcn (if cfcn=None, defaults to the mean) of each column specified by
-     collapsecols.
-"""
-     def collmean (inlist):
-         s = 0
-         for item in inlist:
-             s = s + item
-         return s/float(len(inlist))
-
-     if type(keepcols) not in [ListType,TupleType]:
-         keepcols = [keepcols]
-     if type(collapsecols) not in [ListType,TupleType]:
-         collapsecols = [collapsecols]
-     if cfcn == None:
-         cfcn = collmean
-     if keepcols == []:
-         means = [0]*len(collapsecols)
-         for i in range(len(collapsecols)):
-             avgcol = colex(listoflists,collapsecols[i])
-             means[i] = cfcn(avgcol)
-             if fcn1:
-                 try:
-                     test = fcn1(avgcol)
-                 except:
-                     test = 'N/A'
-                     means[i] = [means[i], test]
-             if fcn2:
-                 try:
-                     test = fcn2(avgcol)
-                 except:
-                     test = 'N/A'
-                 try:
-                     means[i] = means[i] + [len(avgcol)]
-                 except TypeError:
-                     means[i] = [means[i],len(avgcol)]
-         return means
-     else:
-         values = colex(listoflists,keepcols)
-         uniques = unique(values)
-         uniques.sort()
-         newlist = []
-         if type(keepcols) not in [ListType,TupleType]:  keepcols = [keepcols]
-         for item in uniques:
-             if type(item) not in [ListType,TupleType]:  item =[item]
-             tmprows = linexand(listoflists,keepcols,item)
-             for col in collapsecols:
-                 avgcol = colex(tmprows,col)
-                 item.append(cfcn(avgcol))
-                 if fcn1 <> None:
-                     try:
-                         test = fcn1(avgcol)
-                     except:
-                         test = 'N/A'
-                     item.append(test)
-                 if fcn2 <> None:
-                     try:
-                         test = fcn2(avgcol)
-                     except:
-                         test = 'N/A'
-                     item.append(test)
-                 newlist.append(item)
-         return newlist
-
-
-def dm (listoflists,criterion):
-    """
-Returns rows from the passed list of lists that meet the criteria in
-the passed criterion expression (a string as a function of x; e.g., 'x[3]>=9'
-will return all rows where the 4th column>=9 and "x[2]=='N'" will return rows
-with column 2 equal to the string 'N').
-
-Usage:   dm (listoflists, criterion)
-Returns: rows from listoflists that meet the specified criterion.
-"""
-    function = 'filter(lambda x: '+criterion+',listoflists)'
-    lines = eval(function)
-    return lines
-
-
-def flat(l):
-    """
-Returns the flattened version of a '2D' list.  List-correlate to the a.ravel()()
-method of NumPy arrays.
-
-Usage:    flat(l)
-"""
-    newl = []
-    for i in range(len(l)):
-        for j in range(len(l[i])):
-            newl.append(l[i][j])
-    return newl
-
-
-def linexand (listoflists,columnlist,valuelist):
-    """
-Returns the rows of a list of lists where col (from columnlist) = val
-(from valuelist) for EVERY pair of values (columnlist[i],valuelists[i]).
-len(columnlist) must equal len(valuelist).
-
-Usage:   linexand (listoflists,columnlist,valuelist)
-Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ALL i
-"""
-    if type(columnlist) not in [ListType,TupleType]:
-        columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType]:
-        valuelist = [valuelist]
-    criterion = ''
-    for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
-            critval = '\'' + valuelist[i] + '\''
-        else:
-            critval = str(valuelist[i])
-        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
-    criterion = criterion[0:-3]         # remove the "and" after the last crit
-    function = 'filter(lambda x: '+criterion+',listoflists)'
-    lines = eval(function)
-    return lines
-
-
-def linexor (listoflists,columnlist,valuelist):
-    """
-Returns the rows of a list of lists where col (from columnlist) = val
-(from valuelist) for ANY pair of values (colunmlist[i],valuelist[i[).
-One value is required for each column in columnlist.  If only one value
-exists for columnlist but multiple values appear in valuelist, the
-valuelist values are all assumed to pertain to the same column.
-
-Usage:   linexor (listoflists,columnlist,valuelist)
-Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ANY i
-"""
-    if type(columnlist) not in [ListType,TupleType]:
-        columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType]:
-        valuelist = [valuelist]
-    criterion = ''
-    if len(columnlist) == 1 and len(valuelist) > 1:
-        columnlist = columnlist*len(valuelist)
-    for i in range(len(columnlist)):          # build an exec string
-        if type(valuelist[i])==StringType:
-            critval = '\'' + valuelist[i] + '\''
-        else:
-            critval = str(valuelist[i])
-        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
-    criterion = criterion[0:-2]         # remove the "or" after the last crit
-    function = 'filter(lambda x: '+criterion+',listoflists)'
-    lines = eval(function)
-    return lines
-
-
-def linedelimited (inlist,delimiter):
-    """
-Returns a string composed of elements in inlist, with each element
-separated by 'delimiter.'  Used by function writedelimited.  Use '\t'
-for tab-delimiting.
-
-Usage:   linedelimited (inlist,delimiter)
-"""
-    outstr = ''
-    for item in inlist:
-        if type(item) <> StringType:
-            item = str(item)
-        outstr = outstr + item + delimiter
-    outstr = outstr[0:-1]
-    return outstr
-
-
-def lineincols (inlist,colsize):
-    """
-Returns a string composed of elements in inlist, with each element
-right-aligned in columns of (fixed) colsize.
-
-Usage:   lineincols (inlist,colsize)   where colsize is an integer
-"""
-    outstr = ''
-    for item in inlist:
-        if type(item) <> StringType:
-            item = str(item)
-        size = len(item)
-        if size <= colsize:
-            for i in range(colsize-size):
-                outstr = outstr + ' '
-            outstr = outstr + item
-        else:
-            outstr = outstr + item[0:colsize+1]
-    return outstr
-
-
-def lineincustcols (inlist,colsizes):
-    """
-Returns a string composed of elements in inlist, with each element
-right-aligned in a column of width specified by a sequence colsizes.  The
-length of colsizes must be greater than or equal to the number of columns
-in inlist.
-
-Usage:   lineincustcols (inlist,colsizes)
-Returns: formatted string created from inlist
-"""
-    outstr = ''
-    for i in range(len(inlist)):
-        if type(inlist[i]) <> StringType:
-            item = str(inlist[i])
-        else:
-            item = inlist[i]
-        size = len(item)
-        if size <= colsizes[i]:
-            for j in range(colsizes[i]-size):
-                outstr = outstr + ' '
-            outstr = outstr + item
-        else:
-            outstr = outstr + item[0:colsizes[i]+1]
-    return outstr
-
-
-def list2string (inlist,delimit=' '):
-    """
-Converts a 1D list to a single long string for file output, using
-the string.join function.
-
-Usage:   list2string (inlist,delimit=' ')
-Returns: the string created from inlist
-"""
-    stringlist = map(makestr,inlist)
-    return string.join(stringlist,delimit)
-
-
-def makelol(inlist):
-    """
-Converts a 1D list to a 2D list (i.e., a list-of-lists).  Useful when you
-want to use put() to write a 1D list one item per line in the file.
-
-Usage:   makelol(inlist)
-Returns: if l = [1,2,'hi'] then returns [[1],[2],['hi']] etc.
-"""
-    x = []
-    for item in inlist:
-        x.append([item])
-    return x
-
-
-def makestr (x):
-    if type(x) <> StringType:
-        x = str(x)
-    return x
-
-
-def printcc (lst,extra=2):
-    """
-Prints a list of lists in columns, customized by the max size of items
-within the columns (max size of items in col, plus 'extra' number of spaces).
-Use 'dashes' or '\\n' in the list-of-lists to print dashes or blank lines,
-respectively.
-
-Usage:   printcc (lst,extra=2)
-Returns: None
-"""
-    if type(lst[0]) not in [ListType,TupleType]:
-        lst = [lst]
-    rowstokill = []
-    list2print = copy.deepcopy(lst)
-    for i in range(len(lst)):
-        if lst[i] == ['\n'] or lst[i]=='\n' or lst[i]=='dashes' or lst[i]=='' or lst[i]==['']:
-            rowstokill = rowstokill + [i]
-    rowstokill.reverse()   # delete blank rows from the end
-    for row in rowstokill:
-        del list2print[row]
-    maxsize = [0]*len(list2print[0])
-    for col in range(len(list2print[0])):
-        items = colex(list2print,col)
-        items = map(makestr,items)
-        maxsize[col] = max(map(len,items)) + extra
-    for row in lst:
-        if row == ['\n'] or row == '\n' or row == '' or row == ['']:
-            print
-        elif row == ['dashes'] or row == 'dashes':
-            dashes = [0]*len(maxsize)
-            for j in range(len(maxsize)):
-                dashes[j] = '-'*(maxsize[j]-2)
-            print lineincustcols(dashes,maxsize)
-        else:
-            print lineincustcols(row,maxsize)
-    return None
-
-
-def printincols (listoflists,colsize):
-    """
-Prints a list of lists in columns of (fixed) colsize width, where
-colsize is an integer.
-
-Usage:   printincols (listoflists,colsize)
-Returns: None
-"""
-    for row in listoflists:
-        print lineincols(row,colsize)
-    return None
-
-
-def pl (listoflists):
-    """
-Prints a list of lists, 1 list (row) at a time.
-
-Usage:   pl(listoflists)
-Returns: None
-"""
-    for row in listoflists:
-        if row[-1] == '\n':
-            print row,
-        else:
-            print row
-    return None
-
-
-def printl(listoflists):
-    """Alias for pl."""
-    pl(listoflists)
-    return
-
-
-def replace (inlst,oldval,newval):
-    """
-Replaces all occurrences of 'oldval' with 'newval', recursively.
-
-Usage:   replace (inlst,oldval,newval)
-"""
-    lst = inlst*1
-    for i in range(len(lst)):
-        if type(lst[i]) not in [ListType,TupleType]:
-            if lst[i]==oldval: lst[i]=newval
-        else:
-            lst[i] = replace(lst[i],oldval,newval)
-    return lst
-
-
-def recode (inlist,listmap,cols=None):
-    """
-Changes the values in a list to a new set of values (useful when
-you need to recode data from (e.g.) strings to numbers.  cols defaults
-to None (meaning all columns are recoded).
-
-Usage:   recode (inlist,listmap,cols=None)  cols=recode cols, listmap=2D list
-Returns: inlist with the appropriate values replaced with new ones
-"""
-    lst = copy.deepcopy(inlist)
-    if cols != None:
-        if type(cols) not in [ListType,TupleType]:
-            cols = [cols]
-        for col in cols:
-            for row in range(len(lst)):
-                try:
-                    idx = colex(listmap,0).index(lst[row][col])
-                    lst[row][col] = listmap[idx][1]
-                except ValueError:
-                    pass
-    else:
-        for row in range(len(lst)):
-            for col in range(len(lst)):
-                try:
-                    idx = colex(listmap,0).index(lst[row][col])
-                    lst[row][col] = listmap[idx][1]
-                except ValueError:
-                    pass
-    return lst
-
-
-def remap (listoflists,criterion):
-    """
-Remaps values in a given column of a 2D list (listoflists).  This requires
-a criterion as a function of 'x' so that the result of the following is
-returned ... map(lambda x: 'criterion',listoflists).  
-
-Usage:   remap(listoflists,criterion)    criterion=string
-Returns: remapped version of listoflists
-"""
-    function = 'map(lambda x: '+criterion+',listoflists)'
-    lines = eval(function)
-    return lines
-
-
-def roundlist (inlist,digits):
-    """
-Goes through each element in a 1D or 2D inlist, and applies the following
-function to all elements of FloatType ... round(element,digits).
-
-Usage:   roundlist(inlist,digits)
-Returns: list with rounded floats
-"""
-    if type(inlist[0]) in [IntType, FloatType]:
-        inlist = [inlist]
-    l = inlist*1
-    for i in range(len(l)):
-        for j in range(len(l[i])):
-            if type(l[i][j])==FloatType:
-                l[i][j] = round(l[i][j],digits)
-    return l
-
-
-def sortby(listoflists,sortcols):
-    """
-Sorts a list of lists on the column(s) specified in the sequence
-sortcols.
-
-Usage:   sortby(listoflists,sortcols)
-Returns: sorted list, unchanged column ordering
-"""
-    newlist = abut(colex(listoflists,sortcols),listoflists)
-    newlist.sort()
-    try:
-        numcols = len(sortcols)
-    except TypeError:
-        numcols = 1
-    crit = '[' + str(numcols) + ':]'
-    newlist = colex(newlist,crit)
-    return newlist
-
-
-def unique (inlist):
-    """
-Returns all unique items in the passed list.  If the a list-of-lists
-is passed, unique LISTS are found (i.e., items in the first dimension are
-compared).
-
-Usage:   unique (inlist)
-Returns: the unique elements (or rows) in inlist
-"""
-    uniques = []
-    for item in inlist:
-        if item not in uniques:
-            uniques.append(item)
-    return uniques
-
-def duplicates(inlist):
-    """
-Returns duplicate items in the FIRST dimension of the passed list.
-
-Usage:   duplicates (inlist)
-"""
-    dups = []
-    for i in range(len(inlist)):
-        if inlist[i] in inlist[i+1:]:
-            dups.append(inlist[i])
-    return dups
-
-
-def nonrepeats(inlist):
-    """
-Returns items that are NOT duplicated in the first dim of the passed list.
-
-Usage:   nonrepeats (inlist)
-"""
-    nonrepeats = []
-    for i in range(len(inlist)):
-        if inlist.count(inlist[i]) == 1:
-            nonrepeats.append(inlist[i])
-    return nonrepeats
-
-
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-#===================   PSTAT ARRAY FUNCTIONS  =====================
-
-try:                         # DEFINE THESE *ONLY* IF numpy IS AVAILABLE
- import numpy as N
-
- def aabut (source, *args):
-    """
-Like the |Stat abut command.  It concatenates two arrays column-wise
-and returns the result.  CAUTION:  If one array is shorter, it will be
-repeated until it is as long as the other.
-
-Usage:   aabut (source, args)    where args=any # of arrays
-Returns: an array as long as the LONGEST array past, source appearing on the
-         'left', arrays in <args> attached on the 'right'.
-"""
-    if len(source.shape)==1:
-        width = 1
-        source = N.resize(source,[source.shape[0],width])
-    else:
-        width = source.shape[1]
-    for addon in args:
-        if len(addon.shape)==1:
-            width = 1
-            addon = N.resize(addon,[source.shape[0],width])
-        else:
-            width = source.shape[1]
-        if len(addon) < len(source):
-            addon = N.resize(addon,[source.shape[0],addon.shape[1]])
-        elif len(source) < len(addon):
-            source = N.resize(source,[addon.shape[0],source.shape[1]])
-        source = N.concatenate((source,addon),1)
-    return source
-
-
- def acolex (a,indices,axis=1):
-    """
-Extracts specified indices (a list) from passed array, along passed
-axis (column extraction is default).  BEWARE: A 1D array is presumed to be a
-column-array (and that the whole array will be returned as a column).
-
-Usage:   acolex (a,indices,axis=1)
-Returns: the columns of a specified by indices
-"""
-    if type(indices) not in [ListType,TupleType,N.ndarray]:
-        indices = [indices]
-    if len(N.shape(a)) == 1:
-        cols = N.resize(a,[a.shape[0],1])
-    else:
-#        print a[:3]
-        cols = N.take(a,indices,axis)
-#        print cols[:3]
-    return cols
-
-
- def acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None):
-    """
-Averages data in collapsecol, keeping all unique items in keepcols
-(using unique, which keeps unique LISTS of column numbers), retaining
-the unique sets of values in keepcols, the mean for each.  If stderror or
-N of the mean are desired, set either or both parameters to 1.
-
-Usage:   acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
-Returns: unique 'conditions' specified by the contents of columns specified
-         by keepcols, abutted with the mean(s) of column(s) specified by
-         collapsecols
-"""
-    def acollmean (inarray):
-        return N.sum(N.ravel(inarray))
-
-    if type(keepcols) not in [ListType,TupleType,N.ndarray]:
-        keepcols = [keepcols]
-    if type(collapsecols) not in [ListType,TupleType,N.ndarray]:
-        collapsecols = [collapsecols]
-
-    if cfcn == None:
-        cfcn = acollmean
-    if keepcols == []:
-        avgcol = acolex(a,collapsecols)
-        means = N.sum(avgcol)/float(len(avgcol))
-        if fcn1<>None:
-            try:
-                test = fcn1(avgcol)
-            except:
-                test = N.array(['N/A']*len(means))
-            means = aabut(means,test)
-        if fcn2<>None:
-            try:
-                test = fcn2(avgcol)
-            except:
-                test = N.array(['N/A']*len(means))
-            means = aabut(means,test)
-        return means
-    else:
-        if type(keepcols) not in [ListType,TupleType,N.ndarray]:
-            keepcols = [keepcols]
-        values = colex(a,keepcols)   # so that "item" can be appended (below)
-        uniques = unique(values)  # get a LIST, so .sort keeps rows intact
-        uniques.sort()
-        newlist = []
-        for item in uniques:
-            if type(item) not in [ListType,TupleType,N.ndarray]:
-                item =[item]
-            tmprows = alinexand(a,keepcols,item)
-            for col in collapsecols:
-                avgcol = acolex(tmprows,col)
-                item.append(acollmean(avgcol))
-                if fcn1<>None:
-                    try:
-                        test = fcn1(avgcol)
-                    except:
-                        test = 'N/A'
-                    item.append(test)
-                if fcn2<>None:
-                    try:
-                        test = fcn2(avgcol)
-                    except:
-                        test = 'N/A'
-                    item.append(test)
-                newlist.append(item)
-        try:
-            new_a = N.array(newlist)
-        except TypeError:
-            new_a = N.array(newlist,'O')
-        return new_a
-
-
- def adm (a,criterion):
-    """
-Returns rows from the passed list of lists that meet the criteria in
-the passed criterion expression (a string as a function of x).
-
-Usage:   adm (a,criterion)   where criterion is like 'x[2]==37'
-"""
-    function = 'filter(lambda x: '+criterion+',a)'
-    lines = eval(function)
-    try:
-        lines = N.array(lines)
-    except:
-        lines = N.array(lines,dtype='O')
-    return lines
-
-
- def isstring(x):
-    if type(x)==StringType:
-        return 1
-    else:
-        return 0
-
-
- def alinexand (a,columnlist,valuelist):
-    """
-Returns the rows of an array where col (from columnlist) = val
-(from valuelist).  One value is required for each column in columnlist.
-
-Usage:   alinexand (a,columnlist,valuelist)
-Returns: the rows of a where columnlist[i]=valuelist[i] for ALL i
-"""
-    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
-        columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
-        valuelist = [valuelist]
-    criterion = ''
-    for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
-            critval = '\'' + valuelist[i] + '\''
-        else:
-            critval = str(valuelist[i])
-        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
-    criterion = criterion[0:-3]         # remove the "and" after the last crit
-    return adm(a,criterion)
-
-
- def alinexor (a,columnlist,valuelist):
-    """
-Returns the rows of an array where col (from columnlist) = val (from
-valuelist).  One value is required for each column in columnlist.
-The exception is if either columnlist or valuelist has only 1 value,
-in which case that item will be expanded to match the length of the
-other list.
-
-Usage:   alinexor (a,columnlist,valuelist)
-Returns: the rows of a where columnlist[i]=valuelist[i] for ANY i
-"""
-    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
-        columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
-        valuelist = [valuelist]
-    criterion = ''
-    if len(columnlist) == 1 and len(valuelist) > 1:
-        columnlist = columnlist*len(valuelist)
-    elif len(valuelist) == 1 and len(columnlist) > 1:
-        valuelist = valuelist*len(columnlist)
-    for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
-            critval = '\'' + valuelist[i] + '\''
-        else:
-            critval = str(valuelist[i])
-        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
-    criterion = criterion[0:-2]         # remove the "or" after the last crit
-    return adm(a,criterion)
-
-
- def areplace (a,oldval,newval):
-    """
-Replaces all occurrences of oldval with newval in array a.
-
-Usage:   areplace(a,oldval,newval)
-"""
-    return N.where(a==oldval,newval,a)
-
-
- def arecode (a,listmap,col='all'):
-    """
-Remaps the values in an array to a new set of values (useful when
-you need to recode data from (e.g.) strings to numbers as most stats
-packages require.  Can work on SINGLE columns, or 'all' columns at once.
-@@@BROKEN 2007-11-26
-
-Usage:   arecode (a,listmap,col='all')
-Returns: a version of array a where listmap[i][0] = (instead) listmap[i][1]
-"""
-    ashape = a.shape
-    if col == 'all':
-        work = a.ravel()
-    else:
-        work = acolex(a,col)
-        work = work.ravel()
-    for pair in listmap:
-        if type(pair[1]) == StringType or work.dtype.char=='O' or a.dtype.char=='O':
-            work = N.array(work,dtype='O')
-            a = N.array(a,dtype='O')
-            for i in range(len(work)):
-                if work[i]==pair[0]:
-                    work[i] = pair[1]
-            if col == 'all':
-                return N.reshape(work,ashape)
-            else:
-                return N.concatenate([a[:,0:col],work[:,N.newaxis],a[:,col+1:]],1)
-        else:   # must be a non-Object type array and replacement
-            work = N.where(work==pair[0],pair[1],work)
-            return N.concatenate([a[:,0:col],work[:,N.newaxis],a[:,col+1:]],1)
-
-
- def arowcompare(row1, row2):
-    """
-Compares two rows from an array, regardless of whether it is an
-array of numbers or of python objects (which requires the cmp function).
-@@@PURPOSE? 2007-11-26
-
-Usage:   arowcompare(row1,row2)
-Returns: an array of equal length containing 1s where the two rows had
-         identical elements and 0 otherwise
-"""
-    return 
-    if row1.dtype.char=='O' or row2.dtype=='O':
-        cmpvect = N.logical_not(abs(N.array(map(cmp,row1,row2)))) # cmp fcn gives -1,0,1
-    else:
-        cmpvect = N.equal(row1,row2)
-    return cmpvect
-
-
- def arowsame(row1, row2):
-    """
-Compares two rows from an array, regardless of whether it is an
-array of numbers or of python objects (which requires the cmp function).
-
-Usage:   arowsame(row1,row2)
-Returns: 1 if the two rows are identical, 0 otherwise.
-"""
-    cmpval = N.alltrue(arowcompare(row1,row2))
-    return cmpval
-
-
- def asortrows(a,axis=0):
-    """
-Sorts an array "by rows".  This differs from the Numeric.sort() function,
-which sorts elements WITHIN the given axis.  Instead, this function keeps
-the elements along the given axis intact, but shifts them 'up or down'
-relative to one another.
-
-Usage:   asortrows(a,axis=0)
-Returns: sorted version of a
-"""
-    return N.sort(a,axis=axis,kind='mergesort')
-
-
- def aunique(inarray):
-    """
-Returns unique items in the FIRST dimension of the passed array. Only
-works on arrays NOT including string items.
-
-Usage:   aunique (inarray)
-"""
-    uniques = N.array([inarray[0]])
-    if len(uniques.shape) == 1:            # IF IT'S A 1D ARRAY
-        for item in inarray[1:]:
-            if N.add.reduce(N.equal(uniques,item).ravel()) == 0:
-                try:
-                    uniques = N.concatenate([uniques,N.array[N.newaxis,:]])
-                except TypeError:
-                    uniques = N.concatenate([uniques,N.array([item])])
-    else:                                  # IT MUST BE A 2+D ARRAY
-        if inarray.dtype.char != 'O':  # not an Object array
-            for item in inarray[1:]:
-                if not N.sum(N.alltrue(N.equal(uniques,item),1)):
-                    try:
-                        uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
-                    except TypeError:    # the item to add isn't a list
-                        uniques = N.concatenate([uniques,N.array([item])])
-                else:
-                    pass  # this item is already in the uniques array
-        else:   # must be an Object array, alltrue/equal functions don't work
-            for item in inarray[1:]:
-                newflag = 1
-                for unq in uniques:  # NOTE: cmp --> 0=same, -1=<, 1=>
-                    test = N.sum(abs(N.array(map(cmp,item,unq))))
-                    if test == 0:   # if item identical to any 1 row in uniques
-                        newflag = 0 # then not a novel item to add
-                        break
-                if newflag == 1:
-                    try:
-                        uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
-                    except TypeError:    # the item to add isn't a list
-                        uniques = N.concatenate([uniques,N.array([item])])
-    return uniques
-
-
- def aduplicates(inarray):
-    """
-Returns duplicate items in the FIRST dimension of the passed array. Only
-works on arrays NOT including string items.
-
-Usage:   aunique (inarray)
-"""
-    inarray = N.array(inarray)
-    if len(inarray.shape) == 1:            # IF IT'S A 1D ARRAY
-        dups = []
-        inarray = inarray.tolist()
-        for i in range(len(inarray)):
-            if inarray[i] in inarray[i+1:]:
-                dups.append(inarray[i])
-        dups = aunique(dups)
-    else:                                  # IT MUST BE A 2+D ARRAY
-        dups = []
-        aslist = inarray.tolist()
-        for i in range(len(aslist)):
-            if aslist[i] in aslist[i+1:]:
-                dups.append(aslist[i])
-        dups = unique(dups)
-        dups = N.array(dups)
-    return dups
-
-except ImportError:    # IF NUMERIC ISN'T AVAILABLE, SKIP ALL arrayfuncs
- pass
diff --git a/v14/utils/stats.py b/v14/utils/stats.py
deleted file mode 100644
index aceed824..00000000
--- a/v14/utils/stats.py
+++ /dev/null
@@ -1,4528 +0,0 @@
-# Copyright (c) 1999-2008 Gary Strangman; All Rights Reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Comments and/or additions are welcome (send e-mail to:
-# strang@nmr.mgh.harvard.edu).
-#
-"""
-stats.py module
-
-(Requires pstat.py module.)
-
-#################################################
-#######  Written by:  Gary Strangman  ###########
-#######  Last modified:  Oct 31, 2008 ###########
-#################################################
-
-A collection of basic statistical functions for python.  The function
-names appear below.
-
-IMPORTANT:  There are really *3* sets of functions.  The first set has an 'l'
-prefix, which can be used with list or tuple arguments.  The second set has
-an 'a' prefix, which can accept NumPy array arguments.  These latter
-functions are defined only when NumPy is available on the system.  The third
-type has NO prefix (i.e., has the name that appears below).  Functions of
-this set are members of a "Dispatch" class, c/o David Ascher.  This class
-allows different functions to be called depending on the type of the passed
-arguments.  Thus, stats.mean is a member of the Dispatch class and
-stats.mean(range(20)) will call stats.lmean(range(20)) while
-stats.mean(Numeric.arange(20)) will call stats.amean(Numeric.arange(20)).
-This is a handy way to keep consistent function names when different
-argument types require different functions to be called.  Having
-implementated the Dispatch class, however, means that to get info on
-a given function, you must use the REAL function name ... that is
-"print stats.lmean.__doc__" or "print stats.amean.__doc__" work fine,
-while "print stats.mean.__doc__" will print the doc for the Dispatch
-class.  NUMPY FUNCTIONS ('a' prefix) generally have more argument options
-but should otherwise be consistent with the corresponding list functions.
-
-Disclaimers:  The function list is obviously incomplete and, worse, the
-functions are not optimized.  All functions have been tested (some more
-so than others), but they are far from bulletproof.  Thus, as with any
-free software, no warranty or guarantee is expressed or implied. :-)  A
-few extra functions that don't appear in the list below can be found by
-interested treasure-hunters.  These functions don't necessarily have
-both list and array versions but were deemed useful
-
-CENTRAL TENDENCY:  geometricmean
-                   harmonicmean
-                   mean
-                   median
-                   medianscore
-                   mode
-
-MOMENTS:  moment
-          variation
-          skew
-          kurtosis
-          skewtest   (for Numpy arrays only)
-          kurtosistest (for Numpy arrays only)
-          normaltest (for Numpy arrays only)
-
-ALTERED VERSIONS:  tmean  (for Numpy arrays only)
-                   tvar   (for Numpy arrays only)
-                   tmin   (for Numpy arrays only)
-                   tmax   (for Numpy arrays only)
-                   tstdev (for Numpy arrays only)
-                   tsem   (for Numpy arrays only)
-                   describe
-
-FREQUENCY STATS:  itemfreq
-                  scoreatpercentile
-                  percentileofscore
-                  histogram
-                  cumfreq
-                  relfreq
-
-VARIABILITY:  obrientransform
-              samplevar
-              samplestdev
-              signaltonoise (for Numpy arrays only)
-              var
-              stdev
-              sterr
-              sem
-              z
-              zs
-              zmap (for Numpy arrays only)
-
-TRIMMING FCNS:  threshold (for Numpy arrays only)
-                trimboth
-                trim1
-                round (round all vals to 'n' decimals; Numpy only)
-
-CORRELATION FCNS:  covariance  (for Numpy arrays only)
-                   correlation (for Numpy arrays only)
-                   paired
-                   pearsonr
-                   spearmanr
-                   pointbiserialr
-                   kendalltau
-                   linregress
-
-INFERENTIAL STATS:  ttest_1samp
-                    ttest_ind
-                    ttest_rel
-                    chisquare
-                    ks_2samp
-                    mannwhitneyu
-                    ranksums
-                    wilcoxont
-                    kruskalwallish
-                    friedmanchisquare
-
-PROBABILITY CALCS:  chisqprob
-                    erfcc
-                    zprob
-                    ksprob
-                    fprob
-                    betacf
-                    gammln
-                    betai
-
-ANOVA FUNCTIONS:  F_oneway
-                  F_value
-
-SUPPORT FUNCTIONS:  writecc
-                    incr
-                    sign  (for Numpy arrays only)
-                    sum
-                    cumsum
-                    ss
-                    summult
-                    sumdiffsquared
-                    square_of_sums
-                    shellsort
-                    rankdata
-                    outputpairedstats
-                    findwithin
-"""
-## CHANGE LOG:
-## ===========
-## 09-07-21 ... added capability for getting the 'proportion' out of l/amannwhitneyu (but comment-disabled)
-## 08-10-31 ... fixed import LinearAlgebra bug before glm fcns
-## 07-11-26 ... conversion for numpy started
-## 07-05-16 ... added Lin's Concordance Correlation Coefficient (alincc) and acov
-## 05-08-21 ... added "Dice's coefficient"
-## 04-10-26 ... added ap2t(), an ugly fcn for converting p-vals to T-vals
-## 04-04-03 ... added amasslinregress() function to do regression on N-D arrays
-## 03-01-03 ... CHANGED VERSION TO 0.6
-##              fixed atsem() to properly handle limits=None case
-##              improved histogram and median functions (estbinwidth) and
-##                   fixed atvar() function (wrong answers for neg numbers?!?)
-## 02-11-19 ... fixed attest_ind and attest_rel for div-by-zero Overflows
-## 02-05-10 ... fixed lchisqprob indentation (failed when df=even)
-## 00-12-28 ... removed aanova() to separate module, fixed licensing to
-##                   match Python License, fixed doc string & imports
-## 00-04-13 ... pulled all "global" statements, except from aanova()
-##              added/fixed lots of documentation, removed io.py dependency
-##              changed to version 0.5
-## 99-11-13 ... added asign() function
-## 99-11-01 ... changed version to 0.4 ... enough incremental changes now
-## 99-10-25 ... added acovariance and acorrelation functions
-## 99-10-10 ... fixed askew/akurtosis to avoid divide-by-zero errors
-##              added aglm function (crude, but will be improved)
-## 99-10-04 ... upgraded acumsum, ass, asummult, asamplevar, avar, etc. to
-##                   all handle lists of 'dimension's and keepdims
-##              REMOVED ar0, ar2, ar3, ar4 and replaced them with around
-##              reinserted fixes for abetai to avoid math overflows
-## 99-09-05 ... rewrote achisqprob/aerfcc/aksprob/afprob/abetacf/abetai to
-##                   handle multi-dimensional arrays (whew!)
-## 99-08-30 ... fixed l/amoment, l/askew, l/akurtosis per D'Agostino (1990)
-##              added anormaltest per same reference
-##              re-wrote azprob to calc arrays of probs all at once
-## 99-08-22 ... edited attest_ind printing section so arrays could be rounded
-## 99-08-19 ... fixed amean and aharmonicmean for non-error(!) overflow on
-##                   short/byte arrays (mean of #s btw 100-300 = -150??)
-## 99-08-09 ... fixed asum so that the None case works for Byte arrays
-## 99-08-08 ... fixed 7/3 'improvement' to handle t-calcs on N-D arrays
-## 99-07-03 ... improved attest_ind, attest_rel (zero-division errortrap)
-## 99-06-24 ... fixed bug(?) in attest_ind (n1=a.shape[0])
-## 04/11/99 ... added asignaltonoise, athreshold functions, changed all
-##                   max/min in array section to N.maximum/N.minimum,
-##                   fixed square_of_sums to prevent integer overflow
-## 04/10/99 ... !!! Changed function name ... sumsquared ==> square_of_sums
-## 03/18/99 ... Added ar0, ar2, ar3 and ar4 rounding functions
-## 02/28/99 ... Fixed aobrientransform to return an array rather than a list
-## 01/15/99 ... Essentially ceased updating list-versions of functions (!!!)
-## 01/13/99 ... CHANGED TO VERSION 0.3
-##              fixed bug in a/lmannwhitneyu p-value calculation
-## 12/31/98 ... fixed variable-name bug in ldescribe
-## 12/19/98 ... fixed bug in findwithin (fcns needed pstat. prefix)
-## 12/16/98 ... changed amedianscore to return float (not array) for 1 score
-## 12/14/98 ... added atmin and atmax functions
-##              removed umath from import line (not needed)
-##              l/ageometricmean modified to reduce chance of overflows (take
-##                   nth root first, then multiply)
-## 12/07/98 ... added __version__variable (now 0.2)
-##              removed all 'stats.' from anova() fcn
-## 12/06/98 ... changed those functions (except shellsort) that altered
-##                   arguments in-place ... cumsum, ranksort, ...
-##              updated (and fixed some) doc-strings
-## 12/01/98 ... added anova() function (requires NumPy)
-##              incorporated Dispatch class
-## 11/12/98 ... added functionality to amean, aharmonicmean, ageometricmean
-##              added 'asum' function (added functionality to N.add.reduce)
-##              fixed both moment and amoment (two errors)
-##              changed name of skewness and askewness to skew and askew
-##              fixed (a)histogram (which sometimes counted points <lowerlimit)
-
-import pstat               # required 3rd party module
-import math, string, copy  # required python modules
-from types import *
-
-__version__ = 0.6
-
-############# DISPATCH CODE ##############
-
-
-class Dispatch:
-    """
-The Dispatch class, care of David Ascher, allows different functions to
-be called depending on the argument types.  This way, there can be one
-function name regardless of the argument type.  To access function doc
-in stats.py module, prefix the function with an 'l' or 'a' for list or
-array arguments, respectively.  That is, print stats.lmean.__doc__ or
-print stats.amean.__doc__ or whatever.
-"""
-
-    def __init__(self, *tuples):
-        self._dispatch = {}
-        for func, types in tuples:
-            for t in types:
-                if t in self._dispatch.keys():
-                    raise ValueError, "can't have two dispatches on "+str(t)
-                self._dispatch[t] = func
-        self._types = self._dispatch.keys()
-
-    def __call__(self, arg1, *args, **kw):
-        if type(arg1) not in self._types:
-            raise TypeError, "don't know how to dispatch %s arguments" %  type(arg1)
-        return apply(self._dispatch[type(arg1)], (arg1,) + args, kw)
-
-
-##########################################################################
-########################   LIST-BASED FUNCTIONS   ########################
-##########################################################################
-
-### Define these regardless
-
-####################################
-#######  CENTRAL TENDENCY  #########
-####################################
-
-def lgeometricmean (inlist):
-    """
-Calculates the geometric mean of the values in the passed list.
-That is:  n-th root of (x1 * x2 * ... * xn).  Assumes a '1D' list.
-
-Usage:   lgeometricmean(inlist)
-"""
-    mult = 1.0
-    one_over_n = 1.0/len(inlist)
-    for item in inlist:
-        mult = mult * pow(item,one_over_n)
-    return mult
-
-
-def lharmonicmean (inlist):
-    """
-Calculates the harmonic mean of the values in the passed list.
-That is:  n / (1/x1 + 1/x2 + ... + 1/xn).  Assumes a '1D' list.
-
-Usage:   lharmonicmean(inlist)
-"""
-    sum = 0
-    for item in inlist:
-        sum = sum + 1.0/item
-    return len(inlist) / sum
-
-
-def lmean (inlist):
-    """
-Returns the arithematic mean of the values in the passed list.
-Assumes a '1D' list, but will function on the 1st dim of an array(!).
-
-Usage:   lmean(inlist)
-"""
-    sum = 0
-    for item in inlist:
-        sum = sum + item
-    return sum/float(len(inlist))
-
-
-def lmedian (inlist,numbins=1000):
-    """
-Returns the computed median value of a list of numbers, given the
-number of bins to use for the histogram (more bins brings the computed value
-closer to the median score, default number of bins = 1000).  See G.W.
-Heiman's Basic Stats (1st Edition), or CRC Probability & Statistics.
-
-Usage:   lmedian (inlist, numbins=1000)
-"""
-    (hist, smallest, binsize, extras) = histogram(inlist,numbins,[min(inlist),max(inlist)]) # make histog
-    cumhist = cumsum(hist)              # make cumulative histogram
-    for i in range(len(cumhist)):        # get 1st(!) index holding 50%ile score
-        if cumhist[i]>=len(inlist)/2.0:
-            cfbin = i
-            break
-    LRL = smallest + binsize*cfbin        # get lower read limit of that bin
-    cfbelow = cumhist[cfbin-1]
-    freq = float(hist[cfbin])                # frequency IN the 50%ile bin
-    median = LRL + ((len(inlist)/2.0 - cfbelow)/float(freq))*binsize  # median formula
-    return median
-
-
-def lmedianscore (inlist):
-    """
-Returns the 'middle' score of the passed list.  If there is an even
-number of scores, the mean of the 2 middle scores is returned.
-
-Usage:   lmedianscore(inlist)
-"""
-
-    newlist = copy.deepcopy(inlist)
-    newlist.sort()
-    if len(newlist) % 2 == 0:   # if even number of scores, average middle 2
-        index = len(newlist)/2  # integer division correct
-        median = float(newlist[index] + newlist[index-1]) /2
-    else:
-        index = len(newlist)/2  # int divsion gives mid value when count from 0
-        median = newlist[index]
-    return median
-
-
-def lmode(inlist):
-    """
-Returns a list of the modal (most common) score(s) in the passed
-list.  If there is more than one such score, all are returned.  The
-bin-count for the mode(s) is also returned.
-
-Usage:   lmode(inlist)
-Returns: bin-count for mode(s), a list of modal value(s)
-"""
-
-    scores = pstat.unique(inlist)
-    scores.sort()
-    freq = []
-    for item in scores:
-        freq.append(inlist.count(item))
-    maxfreq = max(freq)
-    mode = []
-    stillmore = 1
-    while stillmore:
-        try:
-            indx = freq.index(maxfreq)
-            mode.append(scores[indx])
-            del freq[indx]
-            del scores[indx]
-        except ValueError:
-            stillmore=0
-    return maxfreq, mode
-
-
-####################################
-############  MOMENTS  #############
-####################################
-
-def lmoment(inlist,moment=1):
-    """
-Calculates the nth moment about the mean for a sample (defaults to
-the 1st moment).  Used to calculate coefficients of skewness and kurtosis.
-
-Usage:   lmoment(inlist,moment=1)
-Returns: appropriate moment (r) from ... 1/n * SUM((inlist(i)-mean)**r)
-"""
-    if moment == 1:
-        return 0.0
-    else:
-        mn = mean(inlist)
-        n = len(inlist)
-        s = 0
-        for x in inlist:
-            s = s + (x-mn)**moment
-        return s/float(n)
-
-
-def lvariation(inlist):
-    """
-Returns the coefficient of variation, as defined in CRC Standard
-Probability and Statistics, p.6.
-
-Usage:   lvariation(inlist)
-"""
-    return 100.0*samplestdev(inlist)/float(mean(inlist))
-
-
-def lskew(inlist):
-    """
-Returns the skewness of a distribution, as defined in Numerical
-Recipies (alternate defn in CRC Standard Probability and Statistics, p.6.)
-
-Usage:   lskew(inlist)
-"""
-    return moment(inlist,3)/pow(moment(inlist,2),1.5)
-
-
-def lkurtosis(inlist):
-    """
-Returns the kurtosis of a distribution, as defined in Numerical
-Recipies (alternate defn in CRC Standard Probability and Statistics, p.6.)
-
-Usage:   lkurtosis(inlist)
-"""
-    return moment(inlist,4)/pow(moment(inlist,2),2.0)
-
-
-def ldescribe(inlist):
-    """
-Returns some descriptive statistics of the passed list (assumed to be 1D).
-
-Usage:   ldescribe(inlist)
-Returns: n, mean, standard deviation, skew, kurtosis
-"""
-    n = len(inlist)
-    mm = (min(inlist),max(inlist))
-    m = mean(inlist)
-    sd = stdev(inlist)
-    sk = skew(inlist)
-    kurt = kurtosis(inlist)
-    return n, mm, m, sd, sk, kurt
-
-
-####################################
-#######  FREQUENCY STATS  ##########
-####################################
-
-def litemfreq(inlist):
-    """
-Returns a list of pairs.  Each pair consists of one of the scores in inlist
-and it's frequency count.  Assumes a 1D list is passed.
-
-Usage:   litemfreq(inlist)
-Returns: a 2D frequency table (col [0:n-1]=scores, col n=frequencies)
-"""
-    scores = pstat.unique(inlist)
-    scores.sort()
-    freq = []
-    for item in scores:
-        freq.append(inlist.count(item))
-    return pstat.abut(scores, freq)
-
-
-def lscoreatpercentile (inlist, percent):
-    """
-Returns the score at a given percentile relative to the distribution
-given by inlist.
-
-Usage:   lscoreatpercentile(inlist,percent)
-"""
-    if percent > 1:
-        print "\nDividing percent>1 by 100 in lscoreatpercentile().\n"
-        percent = percent / 100.0
-    targetcf = percent*len(inlist)
-    h, lrl, binsize, extras = histogram(inlist)
-    cumhist = cumsum(copy.deepcopy(h))
-    for i in range(len(cumhist)):
-        if cumhist[i] >= targetcf:
-            break
-    score = binsize * ((targetcf - cumhist[i-1]) / float(h[i])) + (lrl+binsize*i)
-    return score
-
-
-def lpercentileofscore (inlist, score,histbins=10,defaultlimits=None):
-    """
-Returns the percentile value of a score relative to the distribution
-given by inlist.  Formula depends on the values used to histogram the data(!).
-
-Usage:   lpercentileofscore(inlist,score,histbins=10,defaultlimits=None)
-"""
-
-    h, lrl, binsize, extras = histogram(inlist,histbins,defaultlimits)
-    cumhist = cumsum(copy.deepcopy(h))
-    i = int((score - lrl)/float(binsize))
-    pct = (cumhist[i-1]+((score-(lrl+binsize*i))/float(binsize))*h[i])/float(len(inlist)) * 100
-    return pct
-
-
-def lhistogram (inlist,numbins=10,defaultreallimits=None,printextras=0):
-    """
-Returns (i) a list of histogram bin counts, (ii) the smallest value
-of the histogram binning, and (iii) the bin width (the last 2 are not
-necessarily integers).  Default number of bins is 10.  If no sequence object
-is given for defaultreallimits, the routine picks (usually non-pretty) bins
-spanning all the numbers in the inlist.
-
-Usage:   lhistogram (inlist, numbins=10, defaultreallimits=None,suppressoutput=0)
-Returns: list of bin values, lowerreallimit, binsize, extrapoints
-"""
-    if (defaultreallimits <> None):
-        if type(defaultreallimits) not in [ListType,TupleType] or len(defaultreallimits)==1: # only one limit given, assumed to be lower one & upper is calc'd
-            lowerreallimit = defaultreallimits
-            upperreallimit = 1.000001 * max(inlist)
-        else: # assume both limits given
-            lowerreallimit = defaultreallimits[0]
-            upperreallimit = defaultreallimits[1]
-        binsize = (upperreallimit-lowerreallimit)/float(numbins)
-    else:     # no limits given for histogram, both must be calc'd
-        estbinwidth=(max(inlist)-min(inlist))/float(numbins) +1e-6 #1=>cover all
-        binsize = ((max(inlist)-min(inlist)+estbinwidth))/float(numbins)
-        lowerreallimit = min(inlist) - binsize/2 #lower real limit,1st bin
-    bins = [0]*(numbins)
-    extrapoints = 0
-    for num in inlist:
-        try:
-            if (num-lowerreallimit) < 0:
-                extrapoints = extrapoints + 1
-            else:
-                bintoincrement = int((num-lowerreallimit)/float(binsize))
-                bins[bintoincrement] = bins[bintoincrement] + 1
-        except:
-            extrapoints = extrapoints + 1
-    if (extrapoints > 0 and printextras == 1):
-        print '\nPoints outside given histogram range =',extrapoints
-    return (bins, lowerreallimit, binsize, extrapoints)
-
-
-def lcumfreq(inlist,numbins=10,defaultreallimits=None):
-    """
-Returns a cumulative frequency histogram, using the histogram function.
-
-Usage:   lcumfreq(inlist,numbins=10,defaultreallimits=None)
-Returns: list of cumfreq bin values, lowerreallimit, binsize, extrapoints
-"""
-    h,l,b,e = histogram(inlist,numbins,defaultreallimits)
-    cumhist = cumsum(copy.deepcopy(h))
-    return cumhist,l,b,e
-
-
-def lrelfreq(inlist,numbins=10,defaultreallimits=None):
-    """
-Returns a relative frequency histogram, using the histogram function.
-
-Usage:   lrelfreq(inlist,numbins=10,defaultreallimits=None)
-Returns: list of cumfreq bin values, lowerreallimit, binsize, extrapoints
-"""
-    h,l,b,e = histogram(inlist,numbins,defaultreallimits)
-    for i in range(len(h)):
-        h[i] = h[i]/float(len(inlist))
-    return h,l,b,e
-
-
-####################################
-#####  VARIABILITY FUNCTIONS  ######
-####################################
-
-def lobrientransform(*args):
-    """
-Computes a transform on input data (any number of columns).  Used to
-test for homogeneity of variance prior to running one-way stats.  From
-Maxwell and Delaney, p.112.
-
-Usage:   lobrientransform(*args)
-Returns: transformed data for use in an ANOVA
-"""
-    TINY = 1e-10
-    k = len(args)
-    n = [0.0]*k
-    v = [0.0]*k
-    m = [0.0]*k
-    nargs = []
-    for i in range(k):
-        nargs.append(copy.deepcopy(args[i]))
-        n[i] = float(len(nargs[i]))
-        v[i] = var(nargs[i])
-        m[i] = mean(nargs[i])
-    for j in range(k):
-        for i in range(n[j]):
-            t1 = (n[j]-1.5)*n[j]*(nargs[j][i]-m[j])**2
-            t2 = 0.5*v[j]*(n[j]-1.0)
-            t3 = (n[j]-1.0)*(n[j]-2.0)
-            nargs[j][i] = (t1-t2) / float(t3)
-    check = 1
-    for j in range(k):
-        if v[j] - mean(nargs[j]) > TINY:
-            check = 0
-    if check <> 1:
-        raise ValueError, 'Problem in obrientransform.'
-    else:
-        return nargs
-
-
-def lsamplevar (inlist):
-    """
-Returns the variance of the values in the passed list using
-N for the denominator (i.e., DESCRIBES the sample variance only).
-
-Usage:   lsamplevar(inlist)
-"""
-    n = len(inlist)
-    mn = mean(inlist)
-    deviations = []
-    for item in inlist:
-        deviations.append(item-mn)
-    return ss(deviations)/float(n)
-
-
-def lsamplestdev (inlist):
-    """
-Returns the standard deviation of the values in the passed list using
-N for the denominator (i.e., DESCRIBES the sample stdev only).
-
-Usage:   lsamplestdev(inlist)
-"""
-    return math.sqrt(samplevar(inlist))
-
-
-def lcov (x,y, keepdims=0):
-    """
-Returns the estimated covariance of the values in the passed
-array (i.e., N-1).  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions).  Set keepdims=1 to return an array with the
-same number of dimensions as inarray.
-
-Usage:   lcov(x,y,keepdims=0)
-"""
-
-    n = len(x)
-    xmn = mean(x)
-    ymn = mean(y)
-    xdeviations = [0]*len(x)
-    ydeviations = [0]*len(y)
-    for i in range(len(x)):
-        xdeviations[i] = x[i] - xmn
-        ydeviations[i] = y[i] - ymn
-    ss = 0.0
-    for i in range(len(xdeviations)):
-        ss = ss + xdeviations[i]*ydeviations[i]
-    return ss/float(n-1)
-
-
-def lvar (inlist):
-    """
-Returns the variance of the values in the passed list using N-1
-for the denominator (i.e., for estimating population variance).
-
-Usage:   lvar(inlist)
-"""
-    n = len(inlist)
-    mn = mean(inlist)
-    deviations = [0]*len(inlist)
-    for i in range(len(inlist)):
-        deviations[i] = inlist[i] - mn
-    return ss(deviations)/float(n-1)
-
-
-def lstdev (inlist):
-    """
-Returns the standard deviation of the values in the passed list
-using N-1 in the denominator (i.e., to estimate population stdev).
-
-Usage:   lstdev(inlist)
-"""
-    return math.sqrt(var(inlist))
-
-
-def lsterr(inlist):
-    """
-Returns the standard error of the values in the passed list using N-1
-in the denominator (i.e., to estimate population standard error).
-
-Usage:   lsterr(inlist)
-"""
-    return stdev(inlist) / float(math.sqrt(len(inlist)))
-
-
-def lsem (inlist):
-    """
-Returns the estimated standard error of the mean (sx-bar) of the
-values in the passed list.  sem = stdev / sqrt(n)
-
-Usage:   lsem(inlist)
-"""
-    sd = stdev(inlist)
-    n = len(inlist)
-    return sd/math.sqrt(n)
-
-
-def lz (inlist, score):
-    """
-Returns the z-score for a given input score, given that score and the
-list from which that score came.  Not appropriate for population calculations.
-
-Usage:   lz(inlist, score)
-"""
-    z = (score-mean(inlist))/samplestdev(inlist)
-    return z
-
-
-def lzs (inlist):
-    """
-Returns a list of z-scores, one for each score in the passed list.
-
-Usage:   lzs(inlist)
-"""
-    zscores = []
-    for item in inlist:
-        zscores.append(z(inlist,item))
-    return zscores
-
-
-####################################
-#######  TRIMMING FUNCTIONS  #######
-####################################
-
-def ltrimboth (l,proportiontocut):
-    """
-Slices off the passed proportion of items from BOTH ends of the passed
-list (i.e., with proportiontocut=0.1, slices 'leftmost' 10% AND 'rightmost'
-10% of scores.  Assumes list is sorted by magnitude.  Slices off LESS if
-proportion results in a non-integer slice index (i.e., conservatively
-slices off proportiontocut).
-
-Usage:   ltrimboth (l,proportiontocut)
-Returns: trimmed version of list l
-"""
-    lowercut = int(proportiontocut*len(l))
-    uppercut = len(l) - lowercut
-    return l[lowercut:uppercut]
-
-
-def ltrim1 (l,proportiontocut,tail='right'):
-    """
-Slices off the passed proportion of items from ONE end of the passed
-list (i.e., if proportiontocut=0.1, slices off 'leftmost' or 'rightmost'
-10% of scores).  Slices off LESS if proportion results in a non-integer
-slice index (i.e., conservatively slices off proportiontocut).
-
-Usage:   ltrim1 (l,proportiontocut,tail='right')  or set tail='left'
-Returns: trimmed version of list l
-"""
-    if tail == 'right':
-        lowercut = 0
-        uppercut = len(l) - int(proportiontocut*len(l))
-    elif tail == 'left':
-        lowercut = int(proportiontocut*len(l))
-        uppercut = len(l)
-    return l[lowercut:uppercut]
-
-
-####################################
-#####  CORRELATION FUNCTIONS  ######
-####################################
-
-def lpaired(x,y):
-    """
-Interactively determines the type of data and then runs the
-appropriated statistic for paired group data.
-
-Usage:   lpaired(x,y)
-Returns: appropriate statistic name, value, and probability
-"""
-    samples = ''
-    while samples not in ['i','r','I','R','c','C']:
-        print '\nIndependent or related samples, or correlation (i,r,c): ',
-        samples = raw_input()
-
-    if samples in ['i','I','r','R']:
-        print '\nComparing variances ...',
-# USE O'BRIEN'S TEST FOR HOMOGENEITY OF VARIANCE, Maxwell & delaney, p.112
-        r = obrientransform(x,y)
-        f,p = F_oneway(pstat.colex(r,0),pstat.colex(r,1))
-        if p<0.05:
-            vartype='unequal, p='+str(round(p,4))
-        else:
-            vartype='equal'
-        print vartype
-        if samples in ['i','I']:
-            if vartype[0]=='e':
-                t,p = ttest_ind(x,y,0)
-                print '\nIndependent samples t-test:  ', round(t,4),round(p,4)
-            else:
-                if len(x)>20 or len(y)>20:
-                    z,p = ranksums(x,y)
-                    print '\nRank Sums test (NONparametric, n>20):  ', round(z,4),round(p,4)
-                else:
-                    u,p = mannwhitneyu(x,y)
-                    print '\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u,4),round(p,4)
-
-        else:  # RELATED SAMPLES
-            if vartype[0]=='e':
-                t,p = ttest_rel(x,y,0)
-                print '\nRelated samples t-test:  ', round(t,4),round(p,4)
-            else:
-                t,p = ranksums(x,y)
-                print '\nWilcoxon T-test (NONparametric):  ', round(t,4),round(p,4)
-    else:  # CORRELATION ANALYSIS
-        corrtype = ''
-        while corrtype not in ['c','C','r','R','d','D']:
-            print '\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ',
-            corrtype = raw_input()
-        if corrtype in ['c','C']:
-            m,b,r,p,see = linregress(x,y)
-            print '\nLinear regression for continuous variables ...'
-            lol = [['Slope','Intercept','r','Prob','SEestimate'],[round(m,4),round(b,4),round(r,4),round(p,4),round(see,4)]]
-            pstat.printcc(lol)
-        elif corrtype in ['r','R']:
-            r,p = spearmanr(x,y)
-            print '\nCorrelation for ranked variables ...'
-            print "Spearman's r: ",round(r,4),round(p,4)
-        else: # DICHOTOMOUS
-            r,p = pointbiserialr(x,y)
-            print '\nAssuming x contains a dichotomous variable ...'
-            print 'Point Biserial r: ',round(r,4),round(p,4)
-    print '\n\n'
-    return None
-
-
-def lpearsonr(x,y):
-    """
-Calculates a Pearson correlation coefficient and the associated
-probability value.  Taken from Heiman's Basic Statistics for the Behav.
-Sci (2nd), p.195.
-
-Usage:   lpearsonr(x,y)      where x and y are equal-length lists
-Returns: Pearson's r value, two-tailed p-value
-"""
-    TINY = 1.0e-30
-    if len(x) <> len(y):
-        raise ValueError, 'Input values not paired in pearsonr.  Aborting.'
-    n = len(x)
-    x = map(float,x)
-    y = map(float,y)
-    xmean = mean(x)
-    ymean = mean(y)
-    r_num = n*(summult(x,y)) - sum(x)*sum(y)
-    r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
-    r = (r_num / r_den)  # denominator already a float
-    df = n-2
-    t = r*math.sqrt(df/((1.0-r+TINY)*(1.0+r+TINY)))
-    prob = betai(0.5*df,0.5,df/float(df+t*t))
-    return r, prob
-
-
-def llincc(x,y):
-    """
-Calculates Lin's concordance correlation coefficient.
-
-Usage:   alincc(x,y)    where x, y are equal-length arrays
-Returns: Lin's CC
-"""
-    covar = lcov(x,y)*(len(x)-1)/float(len(x))  # correct denom to n
-    xvar = lvar(x)*(len(x)-1)/float(len(x))  # correct denom to n
-    yvar = lvar(y)*(len(y)-1)/float(len(y))  # correct denom to n
-    lincc = (2 * covar) / ((xvar+yvar) +((amean(x)-amean(y))**2))
-    return lincc
-
-
-def lspearmanr(x,y):
-    """
-Calculates a Spearman rank-order correlation coefficient.  Taken
-from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.
-
-Usage:   lspearmanr(x,y)      where x and y are equal-length lists
-Returns: Spearman's r, two-tailed p-value
-"""
-    TINY = 1e-30
-    if len(x) <> len(y):
-        raise ValueError, 'Input values not paired in spearmanr.  Aborting.'
-    n = len(x)
-    rankx = rankdata(x)
-    ranky = rankdata(y)
-    dsq = sumdiffsquared(rankx,ranky)
-    rs = 1 - 6*dsq / float(n*(n**2-1))
-    t = rs * math.sqrt((n-2) / ((rs+1.0)*(1.0-rs)))
-    df = n-2
-    probrs = betai(0.5*df,0.5,df/(df+t*t))  # t already a float
-# probability values for rs are from part 2 of the spearman function in
-# Numerical Recipies, p.510.  They are close to tables, but not exact. (?)
-    return rs, probrs
-
-
-def lpointbiserialr(x,y):
-    """
-Calculates a point-biserial correlation coefficient and the associated
-probability value.  Taken from Heiman's Basic Statistics for the Behav.
-Sci (1st), p.194.
-
-Usage:   lpointbiserialr(x,y)      where x,y are equal-length lists
-Returns: Point-biserial r, two-tailed p-value
-"""
-    TINY = 1e-30
-    if len(x) <> len(y):
-        raise ValueError, 'INPUT VALUES NOT PAIRED IN pointbiserialr.  ABORTING.'
-    data = pstat.abut(x,y)
-    categories = pstat.unique(x)
-    if len(categories) <> 2:
-        raise ValueError, "Exactly 2 categories required for pointbiserialr()."
-    else:   # there are 2 categories, continue
-        codemap = pstat.abut(categories,range(2))
-        recoded = pstat.recode(data,codemap,0)
-        x = pstat.linexand(data,0,categories[0])
-        y = pstat.linexand(data,0,categories[1])
-        xmean = mean(pstat.colex(x,1))
-        ymean = mean(pstat.colex(y,1))
-        n = len(data)
-        adjust = math.sqrt((len(x)/float(n))*(len(y)/float(n)))
-        rpb = (ymean - xmean)/samplestdev(pstat.colex(data,1))*adjust
-        df = n-2
-        t = rpb*math.sqrt(df/((1.0-rpb+TINY)*(1.0+rpb+TINY)))
-        prob = betai(0.5*df,0.5,df/(df+t*t))  # t already a float
-        return rpb, prob
-
-
-def lkendalltau(x,y):
-    """
-Calculates Kendall's tau ... correlation of ordinal data.  Adapted
-from function kendl1 in Numerical Recipies.  Needs good test-routine.@@@
-
-Usage:   lkendalltau(x,y)
-Returns: Kendall's tau, two-tailed p-value
-"""
-    n1 = 0
-    n2 = 0
-    iss = 0
-    for j in range(len(x)-1):
-        for k in range(j,len(y)):
-            a1 = x[j] - x[k]
-            a2 = y[j] - y[k]
-            aa = a1 * a2
-            if (aa):             # neither list has a tie
-                n1 = n1 + 1
-                n2 = n2 + 1
-                if aa > 0:
-                    iss = iss + 1
-                else:
-                    iss = iss -1
-            else:
-                if (a1):
-                    n1 = n1 + 1
-                else:
-                    n2 = n2 + 1
-    tau = iss / math.sqrt(n1*n2)
-    svar = (4.0*len(x)+10.0) / (9.0*len(x)*(len(x)-1))
-    z = tau / math.sqrt(svar)
-    prob = erfcc(abs(z)/1.4142136)
-    return tau, prob
-
-
-def llinregress(x,y):
-    """
-Calculates a regression line on x,y pairs.
-
-Usage:   llinregress(x,y)      x,y are equal-length lists of x-y coordinates
-Returns: slope, intercept, r, two-tailed prob, sterr-of-estimate
-"""
-    TINY = 1.0e-20
-    if len(x) <> len(y):
-        raise ValueError, 'Input values not paired in linregress.  Aborting.'
-    n = len(x)
-    x = map(float,x)
-    y = map(float,y)
-    xmean = mean(x)
-    ymean = mean(y)
-    r_num = float(n*(summult(x,y)) - sum(x)*sum(y))
-    r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
-    r = r_num / r_den
-    z = 0.5*math.log((1.0+r+TINY)/(1.0-r+TINY))
-    df = n-2
-    t = r*math.sqrt(df/((1.0-r+TINY)*(1.0+r+TINY)))
-    prob = betai(0.5*df,0.5,df/(df+t*t))
-    slope = r_num / float(n*ss(x) - square_of_sums(x))
-    intercept = ymean - slope*xmean
-    sterrest = math.sqrt(1-r*r)*samplestdev(y)
-    return slope, intercept, r, prob, sterrest
-
-
-####################################
-#####  INFERENTIAL STATISTICS  #####
-####################################
-
-def lttest_1samp(a,popmean,printit=0,name='Sample',writemode='a'):
-    """
-Calculates the t-obtained for the independent samples T-test on ONE group
-of scores a, given a population mean.  If printit=1, results are printed
-to the screen.  If printit='filename', the results are output to 'filename'
-using the given writemode (default=append).  Returns t-value, and prob.
-
-Usage:   lttest_1samp(a,popmean,Name='Sample',printit=0,writemode='a')
-Returns: t-value, two-tailed prob
-"""
-    x = mean(a)
-    v = var(a)
-    n = len(a)
-    df = n-1
-    svar = ((n-1)*v)/float(df)
-    t = (x-popmean)/math.sqrt(svar*(1.0/n))
-    prob = betai(0.5*df,0.5,float(df)/(df+t*t))
-
-    if printit <> 0:
-        statname = 'Single-sample T-test.'
-        outputpairedstats(printit,writemode,
-                          'Population','--',popmean,0,0,0,
-                          name,n,x,v,min(a),max(a),
-                          statname,t,prob)
-    return t,prob
-
-
-def lttest_ind (a, b, printit=0, name1='Samp1', name2='Samp2', writemode='a'):
-    """
-Calculates the t-obtained T-test on TWO INDEPENDENT samples of
-scores a, and b.  From Numerical Recipies, p.483.  If printit=1, results
-are printed to the screen.  If printit='filename', the results are output
-to 'filename' using the given writemode (default=append).  Returns t-value,
-and prob.
-
-Usage:   lttest_ind(a,b,printit=0,name1='Samp1',name2='Samp2',writemode='a')
-Returns: t-value, two-tailed prob
-"""
-    x1 = mean(a)
-    x2 = mean(b)
-    v1 = stdev(a)**2
-    v2 = stdev(b)**2
-    n1 = len(a)
-    n2 = len(b)
-    df = n1+n2-2
-    svar = ((n1-1)*v1+(n2-1)*v2)/float(df)
-    if not svar:
-      svar = 1.0e-26
-    t = (x1-x2)/math.sqrt(svar*(1.0/n1 + 1.0/n2))
-    prob = betai(0.5*df,0.5,df/(df+t*t))
-
-    if printit <> 0:
-        statname = 'Independent samples T-test.'
-        outputpairedstats(printit,writemode,
-                          name1,n1,x1,v1,min(a),max(a),
-                          name2,n2,x2,v2,min(b),max(b),
-                          statname,t,prob)
-    return t,prob
-
-
-def lttest_rel (a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a'):
-    """
-Calculates the t-obtained T-test on TWO RELATED samples of scores,
-a and b.  From Numerical Recipies, p.483.  If printit=1, results are
-printed to the screen.  If printit='filename', the results are output to
-'filename' using the given writemode (default=append).  Returns t-value,
-and prob.
-
-Usage:   lttest_rel(a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a')
-Returns: t-value, two-tailed prob
-"""
-    if len(a)<>len(b):
-        raise ValueError, 'Unequal length lists in ttest_rel.'
-    x1 = mean(a)
-    x2 = mean(b)
-    v1 = var(a)
-    v2 = var(b)
-    n = len(a)
-    cov = 0
-    for i in range(len(a)):
-        cov = cov + (a[i]-x1) * (b[i]-x2)
-    df = n-1
-    cov = cov / float(df)
-    sd = math.sqrt((v1+v2 - 2.0*cov)/float(n))
-    t = (x1-x2)/sd
-    prob = betai(0.5*df,0.5,df/(df+t*t))
-
-    if printit <> 0:
-        statname = 'Related samples T-test.'
-        outputpairedstats(printit,writemode,
-                          name1,n,x1,v1,min(a),max(a),
-                          name2,n,x2,v2,min(b),max(b),
-                          statname,t,prob)
-    return t, prob
-
-
-def lchisquare(f_obs,f_exp=None):
-    """
-Calculates a one-way chi square for list of observed frequencies and returns
-the result.  If no expected frequencies are given, the total N is assumed to
-be equally distributed across all groups.
-
-Usage:   lchisquare(f_obs, f_exp=None)   f_obs = list of observed cell freq.
-Returns: chisquare-statistic, associated p-value
-"""
-    k = len(f_obs)                 # number of groups
-    if f_exp == None:
-        f_exp = [sum(f_obs)/float(k)] * len(f_obs) # create k bins with = freq.
-    chisq = 0
-    for i in range(len(f_obs)):
-        chisq = chisq + (f_obs[i]-f_exp[i])**2 / float(f_exp[i])
-    return chisq, chisqprob(chisq, k-1)
-
-
-def lks_2samp (data1,data2):
-    """
-Computes the Kolmogorov-Smirnof statistic on 2 samples.  From
-Numerical Recipies in C, page 493.
-
-Usage:   lks_2samp(data1,data2)   data1&2 are lists of values for 2 conditions
-Returns: KS D-value, associated p-value
-"""
-    j1 = 0
-    j2 = 0
-    fn1 = 0.0
-    fn2 = 0.0
-    n1 = len(data1)
-    n2 = len(data2)
-    en1 = n1
-    en2 = n2
-    d = 0.0
-    data1.sort()
-    data2.sort()
-    while j1 < n1 and j2 < n2:
-        d1=data1[j1]
-        d2=data2[j2]
-        if d1 <= d2:
-            fn1 = (j1)/float(en1)
-            j1 = j1 + 1
-        if d2 <= d1:
-            fn2 = (j2)/float(en2)
-            j2 = j2 + 1
-        dt = (fn2-fn1)
-        if math.fabs(dt) > math.fabs(d):
-            d = dt
-    try:
-        en = math.sqrt(en1*en2/float(en1+en2))
-        prob = ksprob((en+0.12+0.11/en)*abs(d))
-    except:
-        prob = 1.0
-    return d, prob
-
-
-def lmannwhitneyu(x,y):
-    """
-Calculates a Mann-Whitney U statistic on the provided scores and
-returns the result.  Use only when the n in each condition is < 20 and
-you have 2 independent samples of ranks.  NOTE: Mann-Whitney U is
-significant if the u-obtained is LESS THAN or equal to the critical
-value of U found in the tables.  Equivalent to Kruskal-Wallis H with
-just 2 groups.
-
-Usage:   lmannwhitneyu(data)
-Returns: u-statistic, one-tailed p-value (i.e., p(z(U)))
-"""
-    n1 = len(x)
-    n2 = len(y)
-    ranked = rankdata(x+y)
-    rankx = ranked[0:n1]       # get the x-ranks
-    ranky = ranked[n1:]        # the rest are y-ranks
-    u1 = n1*n2 + (n1*(n1+1))/2.0 - sum(rankx)  # calc U for x
-    u2 = n1*n2 - u1                            # remainder is U for y
-    bigu = max(u1,u2)
-    smallu = min(u1,u2)
-    proportion = bigu/float(n1*n2)
-    T = math.sqrt(tiecorrect(ranked))  # correction factor for tied scores
-    if T == 0:
-        raise ValueError, 'All numbers are identical in lmannwhitneyu'
-    sd = math.sqrt(T*n1*n2*(n1+n2+1)/12.0)
-    z = abs((bigu-n1*n2/2.0) / sd)  # normal approximation for prob calc
-    return smallu, 1.0 - zprob(z) #, proportion
-
-
-def ltiecorrect(rankvals):
-    """
-Corrects for ties in Mann Whitney U and Kruskal Wallis H tests.  See
-Siegel, S. (1956) Nonparametric Statistics for the Behavioral Sciences.
-New York: McGraw-Hill.  Code adapted from |Stat rankind.c code.
-
-Usage:   ltiecorrect(rankvals)
-Returns: T correction factor for U or H
-"""
-    sorted,posn = shellsort(rankvals)
-    n = len(sorted)
-    T = 0.0
-    i = 0
-    while (i<n-1):
-        if sorted[i] == sorted[i+1]:
-            nties = 1
-            while (i<n-1) and (sorted[i] == sorted[i+1]):
-                nties = nties +1
-                i = i +1
-            T = T + nties**3 - nties
-        i = i+1
-    T = T / float(n**3-n)
-    return 1.0 - T
-
-
-def lranksums(x,y):
-    """
-Calculates the rank sums statistic on the provided scores and
-returns the result.  Use only when the n in each condition is > 20 and you
-have 2 independent samples of ranks.
-
-Usage:   lranksums(x,y)
-Returns: a z-statistic, two-tailed p-value
-"""
-    n1 = len(x)
-    n2 = len(y)
-    alldata = x+y
-    ranked = rankdata(alldata)
-    x = ranked[:n1]
-    y = ranked[n1:]
-    s = sum(x)
-    expected = n1*(n1+n2+1) / 2.0
-    z = (s - expected) / math.sqrt(n1*n2*(n1+n2+1)/12.0)
-    prob = 2*(1.0 -zprob(abs(z)))
-    return z, prob
-
-
-def lwilcoxont(x,y):
-    """
-Calculates the Wilcoxon T-test for related samples and returns the
-result.  A non-parametric T-test.
-
-Usage:   lwilcoxont(x,y)
-Returns: a t-statistic, two-tail probability estimate
-"""
-    if len(x) <> len(y):
-        raise ValueError, 'Unequal N in wilcoxont.  Aborting.'
-    d=[]
-    for i in range(len(x)):
-        diff = x[i] - y[i]
-        if diff <> 0:
-            d.append(diff)
-    count = len(d)
-    absd = map(abs,d)
-    absranked = rankdata(absd)
-    r_plus = 0.0
-    r_minus = 0.0
-    for i in range(len(absd)):
-        if d[i] < 0:
-            r_minus = r_minus + absranked[i]
-        else:
-            r_plus = r_plus + absranked[i]
-    wt = min(r_plus, r_minus)
-    mn = count * (count+1) * 0.25
-    se =  math.sqrt(count*(count+1)*(2.0*count+1.0)/24.0)
-    z = math.fabs(wt-mn) / se
-    prob = 2*(1.0 -zprob(abs(z)))
-    return wt, prob
-
-
-def lkruskalwallish(*args):
-    """
-The Kruskal-Wallis H-test is a non-parametric ANOVA for 3 or more
-groups, requiring at least 5 subjects in each group.  This function
-calculates the Kruskal-Wallis H-test for 3 or more independent samples
-and returns the result.
-
-Usage:   lkruskalwallish(*args)
-Returns: H-statistic (corrected for ties), associated p-value
-"""
-    args = list(args)
-    n = [0]*len(args)
-    all = []
-    n = map(len,args)
-    for i in range(len(args)):
-        all = all + args[i]
-    ranked = rankdata(all)
-    T = tiecorrect(ranked)
-    for i in range(len(args)):
-        args[i] = ranked[0:n[i]]
-        del ranked[0:n[i]]
-    rsums = []
-    for i in range(len(args)):
-        rsums.append(sum(args[i])**2)
-        rsums[i] = rsums[i] / float(n[i])
-    ssbn = sum(rsums)
-    totaln = sum(n)
-    h = 12.0 / (totaln*(totaln+1)) * ssbn - 3*(totaln+1)
-    df = len(args) - 1
-    if T == 0:
-        raise ValueError, 'All numbers are identical in lkruskalwallish'
-    h = h / float(T)
-    return h, chisqprob(h,df)
-
-
-def lfriedmanchisquare(*args):
-    """
-Friedman Chi-Square is a non-parametric, one-way within-subjects
-ANOVA.  This function calculates the Friedman Chi-square test for repeated
-measures and returns the result, along with the associated probability
-value.  It assumes 3 or more repeated measures.  Only 3 levels requires a
-minimum of 10 subjects in the study.  Four levels requires 5 subjects per
-level(??).
-
-Usage:   lfriedmanchisquare(*args)
-Returns: chi-square statistic, associated p-value
-"""
-    k = len(args)
-    if k < 3:
-        raise ValueError, 'Less than 3 levels.  Friedman test not appropriate.'
-    n = len(args[0])
-    data = apply(pstat.abut,tuple(args))
-    for i in range(len(data)):
-        data[i] = rankdata(data[i])
-    ssbn = 0
-    for i in range(k):
-        ssbn = ssbn + sum(args[i])**2
-    chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)
-    return chisq, chisqprob(chisq,k-1)
-
-
-####################################
-####  PROBABILITY CALCULATIONS  ####
-####################################
-
-def lchisqprob(chisq,df):
-    """
-Returns the (1-tailed) probability value associated with the provided
-chi-square value and df.  Adapted from chisq.c in Gary Perlman's |Stat.
-
-Usage:   lchisqprob(chisq,df)
-"""
-    BIG = 20.0
-    def ex(x):
-        BIG = 20.0
-        if x < -BIG:
-            return 0.0
-        else:
-            return math.exp(x)
-
-    if chisq <=0 or df < 1:
-        return 1.0
-    a = 0.5 * chisq
-    if df%2 == 0:
-        even = 1
-    else:
-        even = 0
-    if df > 1:
-        y = ex(-a)
-    if even:
-        s = y
-    else:
-        s = 2.0 * zprob(-math.sqrt(chisq))
-    if (df > 2):
-        chisq = 0.5 * (df - 1.0)
-        if even:
-            z = 1.0
-        else:
-            z = 0.5
-        if a > BIG:
-            if even:
-                e = 0.0
-            else:
-                e = math.log(math.sqrt(math.pi))
-            c = math.log(a)
-            while (z <= chisq):
-                e = math.log(z) + e
-                s = s + ex(c*z-a-e)
-                z = z + 1.0
-            return s
-        else:
-            if even:
-                e = 1.0
-            else:
-                e = 1.0 / math.sqrt(math.pi) / math.sqrt(a)
-            c = 0.0
-            while (z <= chisq):
-                e = e * (a/float(z))
-                c = c + e
-                z = z + 1.0
-            return (c*y+s)
-    else:
-        return s
-
-
-def lerfcc(x):
-    """
-Returns the complementary error function erfc(x) with fractional
-error everywhere less than 1.2e-7.  Adapted from Numerical Recipies.
-
-Usage:   lerfcc(x)
-"""
-    z = abs(x)
-    t = 1.0 / (1.0+0.5*z)
-    ans = t * math.exp(-z*z-1.26551223 + t*(1.00002368+t*(0.37409196+t*(0.09678418+t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+t*(-0.82215223+t*0.17087277)))))))))
-    if x >= 0:
-        return ans
-    else:
-        return 2.0 - ans
-
-
-def lzprob(z):
-    """
-Returns the area under the normal curve 'to the left of' the given z value.
-Thus,
-    for z<0, zprob(z) = 1-tail probability
-    for z>0, 1.0-zprob(z) = 1-tail probability
-    for any z, 2.0*(1.0-zprob(abs(z))) = 2-tail probability
-Adapted from z.c in Gary Perlman's |Stat.
-
-Usage:   lzprob(z)
-"""
-    Z_MAX = 6.0    # maximum meaningful z-value
-    if z == 0.0:
-        x = 0.0
-    else:
-        y = 0.5 * math.fabs(z)
-        if y >= (Z_MAX*0.5):
-            x = 1.0
-        elif (y < 1.0):
-            w = y*y
-            x = ((((((((0.000124818987 * w
-                        -0.001075204047) * w +0.005198775019) * w
-                      -0.019198292004) * w +0.059054035642) * w
-                    -0.151968751364) * w +0.319152932694) * w
-                  -0.531923007300) * w +0.797884560593) * y * 2.0
-        else:
-            y = y - 2.0
-            x = (((((((((((((-0.000045255659 * y
-                             +0.000152529290) * y -0.000019538132) * y
-                           -0.000676904986) * y +0.001390604284) * y
-                         -0.000794620820) * y -0.002034254874) * y
-                       +0.006549791214) * y -0.010557625006) * y
-                     +0.011630447319) * y -0.009279453341) * y
-                   +0.005353579108) * y -0.002141268741) * y
-                 +0.000535310849) * y +0.999936657524
-    if z > 0.0:
-        prob = ((x+1.0)*0.5)
-    else:
-        prob = ((1.0-x)*0.5)
-    return prob
-
-
-def lksprob(alam):
-    """
-Computes a Kolmolgorov-Smirnov t-test significance level.  Adapted from
-Numerical Recipies.
-
-Usage:   lksprob(alam)
-"""
-    fac = 2.0
-    sum = 0.0
-    termbf = 0.0
-    a2 = -2.0*alam*alam
-    for j in range(1,201):
-        term = fac*math.exp(a2*j*j)
-        sum = sum + term
-        if math.fabs(term) <= (0.001*termbf) or math.fabs(term) < (1.0e-8*sum):
-            return sum
-        fac = -fac
-        termbf = math.fabs(term)
-    return 1.0             # Get here only if fails to converge; was 0.0!!
-
-
-def lfprob (dfnum, dfden, F):
-    """
-Returns the (1-tailed) significance level (p-value) of an F
-statistic given the degrees of freedom for the numerator (dfR-dfF) and
-the degrees of freedom for the denominator (dfF).
-
-Usage:   lfprob(dfnum, dfden, F)   where usually dfnum=dfbn, dfden=dfwn
-"""
-    p = betai(0.5*dfden, 0.5*dfnum, dfden/float(dfden+dfnum*F))
-    return p
-
-
-def lbetacf(a,b,x):
-    """
-This function evaluates the continued fraction form of the incomplete
-Beta function, betai.  (Adapted from: Numerical Recipies in C.)
-
-Usage:   lbetacf(a,b,x)
-"""
-    ITMAX = 200
-    EPS = 3.0e-7
-
-    bm = az = am = 1.0
-    qab = a+b
-    qap = a+1.0
-    qam = a-1.0
-    bz = 1.0-qab*x/qap
-    for i in range(ITMAX+1):
-        em = float(i+1)
-        tem = em + em
-        d = em*(b-em)*x/((qam+tem)*(a+tem))
-        ap = az + d*am
-        bp = bz+d*bm
-        d = -(a+em)*(qab+em)*x/((qap+tem)*(a+tem))
-        app = ap+d*az
-        bpp = bp+d*bz
-        aold = az
-        am = ap/bpp
-        bm = bp/bpp
-        az = app/bpp
-        bz = 1.0
-        if (abs(az-aold)<(EPS*abs(az))):
-            return az
-    print 'a or b too big, or ITMAX too small in Betacf.'
-
-
-def lgammln(xx):
-    """
-Returns the gamma function of xx.
-    Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
-(Adapted from: Numerical Recipies in C.)
-
-Usage:   lgammln(xx)
-"""
-
-    coeff = [76.18009173, -86.50532033, 24.01409822, -1.231739516,
-             0.120858003e-2, -0.536382e-5]
-    x = xx - 1.0
-    tmp = x + 5.5
-    tmp = tmp - (x+0.5)*math.log(tmp)
-    ser = 1.0
-    for j in range(len(coeff)):
-        x = x + 1
-        ser = ser + coeff[j]/x
-    return -tmp + math.log(2.50662827465*ser)
-
-
-def lbetai(a,b,x):
-    """
-Returns the incomplete beta function:
-
-    I-sub-x(a,b) = 1/B(a,b)*(Integral(0,x) of t^(a-1)(1-t)^(b-1) dt)
-
-where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
-function of a.  The continued fraction formulation is implemented here,
-using the betacf function.  (Adapted from: Numerical Recipies in C.)
-
-Usage:   lbetai(a,b,x)
-"""
-    if (x<0.0 or x>1.0):
-        raise ValueError, 'Bad x in lbetai'
-    if (x==0.0 or x==1.0):
-        bt = 0.0
-    else:
-        bt = math.exp(gammln(a+b)-gammln(a)-gammln(b)+a*math.log(x)+b*
-                      math.log(1.0-x))
-    if (x<(a+1.0)/(a+b+2.0)):
-        return bt*betacf(a,b,x)/float(a)
-    else:
-        return 1.0-bt*betacf(b,a,1.0-x)/float(b)
-
-
-####################################
-#######  ANOVA CALCULATIONS  #######
-####################################
-
-def lF_oneway(*lists):
-    """
-Performs a 1-way ANOVA, returning an F-value and probability given
-any number of groups.  From Heiman, pp.394-7.
-
-Usage:   F_oneway(*lists)    where *lists is any number of lists, one per
-                                  treatment group
-Returns: F value, one-tailed p-value
-"""
-    a = len(lists)           # ANOVA on 'a' groups, each in it's own list
-    means = [0]*a
-    vars = [0]*a
-    ns = [0]*a
-    alldata = []
-    tmp = map(N.array,lists)
-    means = map(amean,tmp)
-    vars = map(avar,tmp)
-    ns = map(len,lists)
-    for i in range(len(lists)):
-        alldata = alldata + lists[i]
-    alldata = N.array(alldata)
-    bign = len(alldata)
-    sstot = ass(alldata)-(asquare_of_sums(alldata)/float(bign))
-    ssbn = 0
-    for list in lists:
-        ssbn = ssbn + asquare_of_sums(N.array(list))/float(len(list))
-    ssbn = ssbn - (asquare_of_sums(alldata)/float(bign))
-    sswn = sstot-ssbn
-    dfbn = a-1
-    dfwn = bign - a
-    msb = ssbn/float(dfbn)
-    msw = sswn/float(dfwn)
-    f = msb/msw
-    prob = fprob(dfbn,dfwn,f)
-    return f, prob
-
-
-def lF_value (ER,EF,dfnum,dfden):
-    """
-Returns an F-statistic given the following:
-        ER  = error associated with the null hypothesis (the Restricted model)
-        EF  = error associated with the alternate hypothesis (the Full model)
-        dfR-dfF = degrees of freedom of the numerator
-        dfF = degrees of freedom associated with the denominator/Full model
-
-Usage:   lF_value(ER,EF,dfnum,dfden)
-"""
-    return ((ER-EF)/float(dfnum) / (EF/float(dfden)))
-
-
-####################################
-########  SUPPORT FUNCTIONS  #######
-####################################
-
-def writecc (listoflists,file,writetype='w',extra=2):
-    """
-Writes a list of lists to a file in columns, customized by the max
-size of items within the columns (max size of items in col, +2 characters)
-to specified file.  File-overwrite is the default.
-
-Usage:   writecc (listoflists,file,writetype='w',extra=2)
-Returns: None
-"""
-    if type(listoflists[0]) not in [ListType,TupleType]:
-        listoflists = [listoflists]
-    outfile = open(file,writetype)
-    rowstokill = []
-    list2print = copy.deepcopy(listoflists)
-    for i in range(len(listoflists)):
-        if listoflists[i] == ['\n'] or listoflists[i]=='\n' or listoflists[i]=='dashes':
-            rowstokill = rowstokill + [i]
-    rowstokill.reverse()
-    for row in rowstokill:
-        del list2print[row]
-    maxsize = [0]*len(list2print[0])
-    for col in range(len(list2print[0])):
-        items = pstat.colex(list2print,col)
-        items = map(pstat.makestr,items)
-        maxsize[col] = max(map(len,items)) + extra
-    for row in listoflists:
-        if row == ['\n'] or row == '\n':
-            outfile.write('\n')
-        elif row == ['dashes'] or row == 'dashes':
-            dashes = [0]*len(maxsize)
-            for j in range(len(maxsize)):
-                dashes[j] = '-'*(maxsize[j]-2)
-            outfile.write(pstat.lineincustcols(dashes,maxsize))
-        else:
-            outfile.write(pstat.lineincustcols(row,maxsize))
-        outfile.write('\n')
-    outfile.close()
-    return None
-
-
-def lincr(l,cap):        # to increment a list up to a max-list of 'cap'
-    """
-Simulate a counting system from an n-dimensional list.
-
-Usage:   lincr(l,cap)   l=list to increment, cap=max values for each list pos'n
-Returns: next set of values for list l, OR -1 (if overflow)
-"""
-    l[0] = l[0] + 1     # e.g., [0,0,0] --> [2,4,3] (=cap)
-    for i in range(len(l)):
-        if l[i] > cap[i] and i < len(l)-1: # if carryover AND not done
-            l[i] = 0
-            l[i+1] = l[i+1] + 1
-        elif l[i] > cap[i] and i == len(l)-1: # overflow past last column, must be finished
-            l = -1
-    return l
-
-
-def lsum (inlist):
-    """
-Returns the sum of the items in the passed list.
-
-Usage:   lsum(inlist)
-"""
-    s = 0
-    for item in inlist:
-        s = s + item
-    return s
-
-
-def lcumsum (inlist):
-    """
-Returns a list consisting of the cumulative sum of the items in the
-passed list.
-
-Usage:   lcumsum(inlist)
-"""
-    newlist = copy.deepcopy(inlist)
-    for i in range(1,len(newlist)):
-        newlist[i] = newlist[i] + newlist[i-1]
-    return newlist
-
-
-def lss(inlist):
-    """
-Squares each value in the passed list, adds up these squares and
-returns the result.
-
-Usage:   lss(inlist)
-"""
-    ss = 0
-    for item in inlist:
-        ss = ss + item*item
-    return ss
-
-
-def lsummult (list1,list2):
-    """
-Multiplies elements in list1 and list2, element by element, and
-returns the sum of all resulting multiplications.  Must provide equal
-length lists.
-
-Usage:   lsummult(list1,list2)
-"""
-    if len(list1) <> len(list2):
-        raise ValueError, "Lists not equal length in summult."
-    s = 0
-    for item1,item2 in pstat.abut(list1,list2):
-        s = s + item1*item2
-    return s
-
-
-def lsumdiffsquared(x,y):
-    """
-Takes pairwise differences of the values in lists x and y, squares
-these differences, and returns the sum of these squares.
-
-Usage:   lsumdiffsquared(x,y)
-Returns: sum[(x[i]-y[i])**2]
-"""
-    sds = 0
-    for i in range(len(x)):
-        sds = sds + (x[i]-y[i])**2
-    return sds
-
-
-def lsquare_of_sums(inlist):
-    """
-Adds the values in the passed list, squares the sum, and returns
-the result.
-
-Usage:   lsquare_of_sums(inlist)
-Returns: sum(inlist[i])**2
-"""
-    s = sum(inlist)
-    return float(s)*s
-
-
-def lshellsort(inlist):
-    """
-Shellsort algorithm.  Sorts a 1D-list.
-
-Usage:   lshellsort(inlist)
-Returns: sorted-inlist, sorting-index-vector (for original list)
-"""
-    n = len(inlist)
-    svec = copy.deepcopy(inlist)
-    ivec = range(n)
-    gap = n/2   # integer division needed
-    while gap >0:
-        for i in range(gap,n):
-            for j in range(i-gap,-1,-gap):
-                while j>=0 and svec[j]>svec[j+gap]:
-                    temp        = svec[j]
-                    svec[j]     = svec[j+gap]
-                    svec[j+gap] = temp
-                    itemp       = ivec[j]
-                    ivec[j]     = ivec[j+gap]
-                    ivec[j+gap] = itemp
-        gap = gap / 2  # integer division needed
-# svec is now sorted inlist, and ivec has the order svec[i] = vec[ivec[i]]
-    return svec, ivec
-
-
-def lrankdata(inlist):
-    """
-Ranks the data in inlist, dealing with ties appropritely.  Assumes
-a 1D inlist.  Adapted from Gary Perlman's |Stat ranksort.
-
-Usage:   lrankdata(inlist)
-Returns: a list of length equal to inlist, containing rank scores
-"""
-    n = len(inlist)
-    svec, ivec = shellsort(inlist)
-    sumranks = 0
-    dupcount = 0
-    newlist = [0]*n
-    for i in range(n):
-        sumranks = sumranks + i
-        dupcount = dupcount + 1
-        if i==n-1 or svec[i] <> svec[i+1]:
-            averank = sumranks / float(dupcount) + 1
-            for j in range(i-dupcount+1,i+1):
-                newlist[ivec[j]] = averank
-            sumranks = 0
-            dupcount = 0
-    return newlist
-
-
-def outputpairedstats(fname,writemode,name1,n1,m1,se1,min1,max1,name2,n2,m2,se2,min2,max2,statname,stat,prob):
-    """
-Prints or write to a file stats for two groups, using the name, n,
-mean, sterr, min and max for each group, as well as the statistic name,
-its value, and the associated p-value.
-
-Usage:   outputpairedstats(fname,writemode,
-                           name1,n1,mean1,stderr1,min1,max1,
-                           name2,n2,mean2,stderr2,min2,max2,
-                           statname,stat,prob)
-Returns: None
-"""
-    suffix = ''                       # for *s after the p-value
-    try:
-        x = prob.shape
-        prob = prob[0]
-    except:
-        pass
-    if  prob < 0.001:  suffix = '  ***'
-    elif prob < 0.01:  suffix = '  **'
-    elif prob < 0.05:  suffix = '  *'
-    title = [['Name','N','Mean','SD','Min','Max']]
-    lofl = title+[[name1,n1,round(m1,3),round(math.sqrt(se1),3),min1,max1],
-                  [name2,n2,round(m2,3),round(math.sqrt(se2),3),min2,max2]]
-    if type(fname)<>StringType or len(fname)==0:
-        print
-        print statname
-        print
-        pstat.printcc(lofl)
-        print
-        try:
-            if stat.shape == ():
-                stat = stat[0]
-            if prob.shape == ():
-                prob = prob[0]
-        except:
-            pass
-        print 'Test statistic = ',round(stat,3),'   p = ',round(prob,3),suffix
-        print
-    else:
-        file = open(fname,writemode)
-        file.write('\n'+statname+'\n\n')
-        file.close()
-        writecc(lofl,fname,'a')
-        file = open(fname,'a')
-        try:
-            if stat.shape == ():
-                stat = stat[0]
-            if prob.shape == ():
-                prob = prob[0]
-        except:
-            pass
-        file.write(pstat.list2string(['\nTest statistic = ',round(stat,4),'   p = ',round(prob,4),suffix,'\n\n']))
-        file.close()
-    return None
-
-
-def lfindwithin (data):
-    """
-Returns an integer representing a binary vector, where 1=within-
-subject factor, 0=between.  Input equals the entire data 2D list (i.e.,
-column 0=random factor, column -1=measured values (those two are skipped).
-Note: input data is in |Stat format ... a list of lists ("2D list") with
-one row per measured value, first column=subject identifier, last column=
-score, one in-between column per factor (these columns contain level
-designations on each factor).  See also stats.anova.__doc__.
-
-Usage:   lfindwithin(data)     data in |Stat format
-"""
-
-    numfact = len(data[0])-1
-    withinvec = 0
-    for col in range(1,numfact):
-        examplelevel = pstat.unique(pstat.colex(data,col))[0]
-        rows = pstat.linexand(data,col,examplelevel)  # get 1 level of this factor
-        factsubjs = pstat.unique(pstat.colex(rows,0))
-        allsubjs = pstat.unique(pstat.colex(data,0))
-        if len(factsubjs) == len(allsubjs):  # fewer Ss than scores on this factor?
-            withinvec = withinvec + (1 << col)
-    return withinvec
-
-
-#########################################################
-#########################################################
-####### DISPATCH LISTS AND TUPLES TO ABOVE FCNS #########
-#########################################################
-#########################################################
-
-## CENTRAL TENDENCY:
-geometricmean = Dispatch ( (lgeometricmean, (ListType, TupleType)), )
-harmonicmean = Dispatch ( (lharmonicmean, (ListType, TupleType)), )
-mean = Dispatch ( (lmean, (ListType, TupleType)), )
-median = Dispatch ( (lmedian, (ListType, TupleType)), )
-medianscore = Dispatch ( (lmedianscore, (ListType, TupleType)), )
-mode = Dispatch ( (lmode, (ListType, TupleType)), )
-
-## MOMENTS:
-moment = Dispatch ( (lmoment, (ListType, TupleType)), )
-variation = Dispatch ( (lvariation, (ListType, TupleType)), )
-skew = Dispatch ( (lskew, (ListType, TupleType)), )
-kurtosis = Dispatch ( (lkurtosis, (ListType, TupleType)), )
-describe = Dispatch ( (ldescribe, (ListType, TupleType)), )
-
-## FREQUENCY STATISTICS:
-itemfreq = Dispatch ( (litemfreq, (ListType, TupleType)), )
-scoreatpercentile = Dispatch ( (lscoreatpercentile, (ListType, TupleType)), )
-percentileofscore = Dispatch ( (lpercentileofscore, (ListType, TupleType)), )
-histogram = Dispatch ( (lhistogram, (ListType, TupleType)), )
-cumfreq = Dispatch ( (lcumfreq, (ListType, TupleType)), )
-relfreq = Dispatch ( (lrelfreq, (ListType, TupleType)), )
-
-## VARIABILITY:
-obrientransform = Dispatch ( (lobrientransform, (ListType, TupleType)), )
-samplevar = Dispatch ( (lsamplevar, (ListType, TupleType)), )
-samplestdev = Dispatch ( (lsamplestdev, (ListType, TupleType)), )
-var = Dispatch ( (lvar, (ListType, TupleType)), )
-stdev = Dispatch ( (lstdev, (ListType, TupleType)), )
-sterr = Dispatch ( (lsterr, (ListType, TupleType)), )
-sem = Dispatch ( (lsem, (ListType, TupleType)), )
-z = Dispatch ( (lz, (ListType, TupleType)), )
-zs = Dispatch ( (lzs, (ListType, TupleType)), )
-
-## TRIMMING FCNS:
-trimboth = Dispatch ( (ltrimboth, (ListType, TupleType)), )
-trim1 = Dispatch ( (ltrim1, (ListType, TupleType)), )
-
-## CORRELATION FCNS:
-paired = Dispatch ( (lpaired, (ListType, TupleType)), )
-pearsonr = Dispatch ( (lpearsonr, (ListType, TupleType)), )
-spearmanr = Dispatch ( (lspearmanr, (ListType, TupleType)), )
-pointbiserialr = Dispatch ( (lpointbiserialr, (ListType, TupleType)), )
-kendalltau = Dispatch ( (lkendalltau, (ListType, TupleType)), )
-linregress = Dispatch ( (llinregress, (ListType, TupleType)), )
-
-## INFERENTIAL STATS:
-ttest_1samp = Dispatch ( (lttest_1samp, (ListType, TupleType)), )
-ttest_ind = Dispatch ( (lttest_ind, (ListType, TupleType)), )
-ttest_rel = Dispatch ( (lttest_rel, (ListType, TupleType)), )
-chisquare = Dispatch ( (lchisquare, (ListType, TupleType)), )
-ks_2samp = Dispatch ( (lks_2samp, (ListType, TupleType)), )
-mannwhitneyu = Dispatch ( (lmannwhitneyu, (ListType, TupleType)), )
-ranksums = Dispatch ( (lranksums, (ListType, TupleType)), )
-tiecorrect = Dispatch ( (ltiecorrect, (ListType, TupleType)), )
-wilcoxont = Dispatch ( (lwilcoxont, (ListType, TupleType)), )
-kruskalwallish = Dispatch ( (lkruskalwallish, (ListType, TupleType)), )
-friedmanchisquare = Dispatch ( (lfriedmanchisquare, (ListType, TupleType)), )
-
-## PROBABILITY CALCS:
-chisqprob = Dispatch ( (lchisqprob, (IntType, FloatType)), )
-zprob = Dispatch ( (lzprob, (IntType, FloatType)), )
-ksprob = Dispatch ( (lksprob, (IntType, FloatType)), )
-fprob = Dispatch ( (lfprob, (IntType, FloatType)), )
-betacf = Dispatch ( (lbetacf, (IntType, FloatType)), )
-betai = Dispatch ( (lbetai, (IntType, FloatType)), )
-erfcc = Dispatch ( (lerfcc, (IntType, FloatType)), )
-gammln = Dispatch ( (lgammln, (IntType, FloatType)), )
-
-## ANOVA FUNCTIONS:
-F_oneway = Dispatch ( (lF_oneway, (ListType, TupleType)), )
-F_value = Dispatch ( (lF_value, (ListType, TupleType)), )
-
-## SUPPORT FUNCTIONS:
-incr = Dispatch ( (lincr, (ListType, TupleType)), )
-sum = Dispatch ( (lsum, (ListType, TupleType)), )
-cumsum = Dispatch ( (lcumsum, (ListType, TupleType)), )
-ss = Dispatch ( (lss, (ListType, TupleType)), )
-summult = Dispatch ( (lsummult, (ListType, TupleType)), )
-square_of_sums = Dispatch ( (lsquare_of_sums, (ListType, TupleType)), )
-sumdiffsquared = Dispatch ( (lsumdiffsquared, (ListType, TupleType)), )
-shellsort = Dispatch ( (lshellsort, (ListType, TupleType)), )
-rankdata = Dispatch ( (lrankdata, (ListType, TupleType)), )
-findwithin = Dispatch ( (lfindwithin, (ListType, TupleType)), )
-
-
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-#=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
-
-try:                         # DEFINE THESE *ONLY* IF NUMERIC IS AVAILABLE
- import numpy as N
- import numpy.linalg as LA
-
-
-#####################################
-########  ACENTRAL TENDENCY  ########
-#####################################
-
- def ageometricmean (inarray,dimension=None,keepdims=0):
-    """
-Calculates the geometric mean of the values in the passed array.
-That is:  n-th root of (x1 * x2 * ... * xn).  Defaults to ALL values in
-the passed array.  Use dimension=None to flatten array first.  REMEMBER: if
-dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
-if dimension is a sequence, it collapses over all specified dimensions.  If
-keepdims is set to 1, the resulting array will have as many dimensions as
-inarray, with only 1 'level' per dim that was collapsed over.
-
-Usage:   ageometricmean(inarray,dimension=None,keepdims=0)
-Returns: geometric mean computed over dim(s) listed in dimension
-"""
-    inarray = N.array(inarray,N.float_)
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        size = len(inarray)
-        mult = N.power(inarray,1.0/size)
-        mult = N.multiply.reduce(mult)
-    elif type(dimension) in [IntType,FloatType]:
-        size = inarray.shape[dimension]
-        mult = N.power(inarray,1.0/size)
-        mult = N.multiply.reduce(mult,dimension)
-        if keepdims == 1:
-            shp = list(inarray.shape)
-            shp[dimension] = 1
-            sum = N.reshape(sum,shp)
-    else: # must be a SEQUENCE of dims to average over
-        dims = list(dimension)
-        dims.sort()
-        dims.reverse()
-        size = N.array(N.multiply.reduce(N.take(inarray.shape,dims)),N.float_)
-        mult = N.power(inarray,1.0/size)
-        for dim in dims:
-            mult = N.multiply.reduce(mult,dim)
-        if keepdims == 1:
-            shp = list(inarray.shape)
-            for dim in dims:
-                shp[dim] = 1
-            mult = N.reshape(mult,shp)
-    return mult
-
-
- def aharmonicmean (inarray,dimension=None,keepdims=0):
-    """
-Calculates the harmonic mean of the values in the passed array.
-That is:  n / (1/x1 + 1/x2 + ... + 1/xn).  Defaults to ALL values in
-the passed array.  Use dimension=None to flatten array first.  REMEMBER: if
-dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
-if dimension is a sequence, it collapses over all specified dimensions.  If
-keepdims is set to 1, the resulting array will have as many dimensions as
-inarray, with only 1 'level' per dim that was collapsed over.
-
-Usage:   aharmonicmean(inarray,dimension=None,keepdims=0)
-Returns: harmonic mean computed over dim(s) in dimension
-"""
-    inarray = inarray.astype(N.float_)
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        size = len(inarray)
-        s = N.add.reduce(1.0 / inarray)
-    elif type(dimension) in [IntType,FloatType]:
-        size = float(inarray.shape[dimension])
-        s = N.add.reduce(1.0/inarray, dimension)
-        if keepdims == 1:
-            shp = list(inarray.shape)
-            shp[dimension] = 1
-            s = N.reshape(s,shp)
-    else: # must be a SEQUENCE of dims to average over
-        dims = list(dimension)
-        dims.sort()
-        nondims = []
-        for i in range(len(inarray.shape)):
-            if i not in dims:
-                nondims.append(i)
-        tinarray = N.transpose(inarray,nondims+dims) # put keep-dims first
-        idx = [0] *len(nondims)
-        if idx == []:
-            size = len(N.ravel(inarray))
-            s = asum(1.0 / inarray)
-            if keepdims == 1:
-                s = N.reshape([s],N.ones(len(inarray.shape)))
-        else:
-            idx[0] = -1
-            loopcap = N.array(tinarray.shape[0:len(nondims)]) -1
-            s = N.zeros(loopcap+1,N.float_)
-            while incr(idx,loopcap) <> -1:
-                s[idx] = asum(1.0/tinarray[idx])
-            size = N.multiply.reduce(N.take(inarray.shape,dims))
-            if keepdims == 1:
-                shp = list(inarray.shape)
-                for dim in dims:
-                    shp[dim] = 1
-                s = N.reshape(s,shp)
-    return size / s
-
-
- def amean (inarray,dimension=None,keepdims=0):
-    """
-Calculates the arithmatic mean of the values in the passed array.
-That is:  1/n * (x1 + x2 + ... + xn).  Defaults to ALL values in the
-passed array.  Use dimension=None to flatten array first.  REMEMBER: if
-dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
-if dimension is a sequence, it collapses over all specified dimensions.  If
-keepdims is set to 1, the resulting array will have as many dimensions as
-inarray, with only 1 'level' per dim that was collapsed over.
-
-Usage:   amean(inarray,dimension=None,keepdims=0)
-Returns: arithematic mean calculated over dim(s) in dimension
-"""
-    if inarray.dtype in [N.int_, N.short,N.ubyte]:
-        inarray = inarray.astype(N.float_)
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        sum = N.add.reduce(inarray)
-        denom = float(len(inarray))
-    elif type(dimension) in [IntType,FloatType]:
-        sum = asum(inarray,dimension)
-        denom = float(inarray.shape[dimension])
-        if keepdims == 1:
-            shp = list(inarray.shape)
-            shp[dimension] = 1
-            sum = N.reshape(sum,shp)
-    else: # must be a TUPLE of dims to average over
-        dims = list(dimension)
-        dims.sort()
-        dims.reverse()
-        sum = inarray *1.0
-        for dim in dims:
-            sum = N.add.reduce(sum,dim)
-        denom = N.array(N.multiply.reduce(N.take(inarray.shape,dims)),N.float_)
-        if keepdims == 1:
-            shp = list(inarray.shape)
-            for dim in dims:
-                shp[dim] = 1
-            sum = N.reshape(sum,shp)
-    return sum/denom
-
-
- def amedian (inarray,numbins=1000):
-    """
-Calculates the COMPUTED median value of an array of numbers, given the
-number of bins to use for the histogram (more bins approaches finding the
-precise median value of the array; default number of bins = 1000).  From
-G.W. Heiman's Basic Stats, or CRC Probability & Statistics.
-NOTE:  THIS ROUTINE ALWAYS uses the entire passed array (flattens it first).
-
-Usage:   amedian(inarray,numbins=1000)
-Returns: median calculated over ALL values in inarray
-"""
-    inarray = N.ravel(inarray)
-    (hist, smallest, binsize, extras) = ahistogram(inarray,numbins,[min(inarray),max(inarray)])
-    cumhist = N.cumsum(hist)            # make cumulative histogram
-    otherbins = N.greater_equal(cumhist,len(inarray)/2.0)
-    otherbins = list(otherbins)         # list of 0/1s, 1s start at median bin
-    cfbin = otherbins.index(1)                # get 1st(!) index holding 50%ile score
-    LRL = smallest + binsize*cfbin        # get lower read limit of that bin
-    cfbelow = N.add.reduce(hist[0:cfbin])        # cum. freq. below bin
-    freq = hist[cfbin]                        # frequency IN the 50%ile bin
-    median = LRL + ((len(inarray)/2.0-cfbelow)/float(freq))*binsize # MEDIAN
-    return median
-
-
- def amedianscore (inarray,dimension=None):
-    """
-Returns the 'middle' score of the passed array.  If there is an even
-number of scores, the mean of the 2 middle scores is returned.  Can function
-with 1D arrays, or on the FIRST dimension of 2D arrays (i.e., dimension can
-be None, to pre-flatten the array, or else dimension must equal 0).
-
-Usage:   amedianscore(inarray,dimension=None)
-Returns: 'middle' score of the array, or the mean of the 2 middle scores
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    inarray = N.sort(inarray,dimension)
-    if inarray.shape[dimension] % 2 == 0:   # if even number of elements
-        indx = inarray.shape[dimension]/2   # integer division correct
-        median = N.asarray(inarray[indx]+inarray[indx-1]) / 2.0
-    else:
-        indx = inarray.shape[dimension] / 2 # integer division correct
-        median = N.take(inarray,[indx],dimension)
-        if median.shape == (1,):
-            median = median[0]
-    return median
-
-
- def amode(a, dimension=None):
-    """
-Returns an array of the modal (most common) score in the passed array.
-If there is more than one such score, ONLY THE FIRST is returned.
-The bin-count for the modal values is also returned.  Operates on whole
-array (dimension=None), or on a given dimension.
-
-Usage:   amode(a, dimension=None)
-Returns: array of bin-counts for mode(s), array of corresponding modal values
-"""
-
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    scores = pstat.aunique(N.ravel(a))       # get ALL unique values
-    testshape = list(a.shape)
-    testshape[dimension] = 1
-    oldmostfreq = N.zeros(testshape)
-    oldcounts = N.zeros(testshape)
-    for score in scores:
-        template = N.equal(a,score)
-        counts = asum(template,dimension,1)
-        mostfrequent = N.where(counts>oldcounts,score,oldmostfreq)
-        oldcounts = N.where(counts>oldcounts,counts,oldcounts)
-        oldmostfreq = mostfrequent
-    return oldcounts, mostfrequent
-
-
- def atmean(a,limits=None,inclusive=(1,1)):
-     """
-Returns the arithmetic mean of all values in an array, ignoring values
-strictly outside the sequence passed to 'limits'.   Note: either limit
-in the sequence, or the value of limits itself, can be set to None.  The
-inclusive list/tuple determines whether the lower and upper limiting bounds
-(respectively) are open/exclusive (0) or closed/inclusive (1).
-
-Usage:   atmean(a,limits=None,inclusive=(1,1))
-"""
-     if a.dtype in [N.int_, N.short,N.ubyte]:
-         a = a.astype(N.float_)
-     if limits == None:
-         return mean(a)
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atmean"
-     if inclusive[0]:         lowerfcn = N.greater_equal
-     else:               lowerfcn = N.greater
-     if inclusive[1]:         upperfcn = N.less_equal
-     else:               upperfcn = N.less
-     if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atmean)."
-     elif limits[0]==None and limits[1]<>None:
-         mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
-         mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
-         mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
-     s = float(N.add.reduce(N.ravel(a*mask)))
-     n = float(N.add.reduce(N.ravel(mask)))
-     return s/n
-
-
- def atvar(a,limits=None,inclusive=(1,1)):
-     """
-Returns the sample variance of values in an array, (i.e., using N-1),
-ignoring values strictly outside the sequence passed to 'limits'.
-Note: either limit in the sequence, or the value of limits itself,
-can be set to None.  The inclusive list/tuple determines whether the lower
-and upper limiting bounds (respectively) are open/exclusive (0) or
-closed/inclusive (1). ASSUMES A FLAT ARRAY (OR ELSE PREFLATTENS).
-
-Usage:   atvar(a,limits=None,inclusive=(1,1))
-"""
-     a = a.astype(N.float_)
-     if limits == None or limits == [None,None]:
-         return avar(a)
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atvar"
-     if inclusive[0]:    lowerfcn = N.greater_equal
-     else:               lowerfcn = N.greater
-     if inclusive[1]:    upperfcn = N.less_equal
-     else:               upperfcn = N.less
-     if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atvar)."
-     elif limits[0]==None and limits[1]<>None:
-         mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
-         mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
-         mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
-
-     a = N.compress(mask,a)  # squish out excluded values
-     return avar(a)
-
-
- def atmin(a,lowerlimit=None,dimension=None,inclusive=1):
-     """
-Returns the minimum value of a, along dimension, including only values less
-than (or equal to, if inclusive=1) lowerlimit.  If the limit is set to None,
-all values in the array are used.
-
-Usage:   atmin(a,lowerlimit=None,dimension=None,inclusive=1)
-"""
-     if inclusive:         lowerfcn = N.greater
-     else:               lowerfcn = N.greater_equal
-     if dimension == None:
-         a = N.ravel(a)
-         dimension = 0
-     if lowerlimit == None:
-         lowerlimit = N.minimum.reduce(N.ravel(a))-11
-     biggest = N.maximum.reduce(N.ravel(a))
-     ta = N.where(lowerfcn(a,lowerlimit),a,biggest)
-     return N.minimum.reduce(ta,dimension)
-
-
- def atmax(a,upperlimit,dimension=None,inclusive=1):
-     """
-Returns the maximum value of a, along dimension, including only values greater
-than (or equal to, if inclusive=1) upperlimit.  If the limit is set to None,
-a limit larger than the max value in the array is used.
-
-Usage:   atmax(a,upperlimit,dimension=None,inclusive=1)
-"""
-     if inclusive:         upperfcn = N.less
-     else:               upperfcn = N.less_equal
-     if dimension == None:
-         a = N.ravel(a)
-         dimension = 0
-     if upperlimit == None:
-         upperlimit = N.maximum.reduce(N.ravel(a))+1
-     smallest = N.minimum.reduce(N.ravel(a))
-     ta = N.where(upperfcn(a,upperlimit),a,smallest)
-     return N.maximum.reduce(ta,dimension)
-
-
- def atstdev(a,limits=None,inclusive=(1,1)):
-     """
-Returns the standard deviation of all values in an array, ignoring values
-strictly outside the sequence passed to 'limits'.   Note: either limit
-in the sequence, or the value of limits itself, can be set to None.  The
-inclusive list/tuple determines whether the lower and upper limiting bounds
-(respectively) are open/exclusive (0) or closed/inclusive (1).
-
-Usage:   atstdev(a,limits=None,inclusive=(1,1))
-"""
-     return N.sqrt(tvar(a,limits,inclusive))
-
-
- def atsem(a,limits=None,inclusive=(1,1)):
-     """
-Returns the standard error of the mean for the values in an array,
-(i.e., using N for the denominator), ignoring values strictly outside
-the sequence passed to 'limits'.   Note: either limit in the sequence,
-or the value of limits itself, can be set to None.  The inclusive list/tuple
-determines whether the lower and upper limiting bounds (respectively) are
-open/exclusive (0) or closed/inclusive (1).
-
-Usage:   atsem(a,limits=None,inclusive=(1,1))
-"""
-     sd = tstdev(a,limits,inclusive)
-     if limits == None or limits == [None,None]:
-         n = float(len(N.ravel(a)))
-         limits = [min(a)-1, max(a)+1]
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atsem"
-     if inclusive[0]:         lowerfcn = N.greater_equal
-     else:               lowerfcn = N.greater
-     if inclusive[1]:         upperfcn = N.less_equal
-     else:               upperfcn = N.less
-     if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atsem)."
-     elif limits[0]==None and limits[1]<>None:
-         mask = upperfcn(a,limits[1])
-     elif limits[0]<>None and limits[1]==None:
-         mask = lowerfcn(a,limits[0])
-     elif limits[0]<>None and limits[1]<>None:
-         mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
-     term1 = N.add.reduce(N.ravel(a*a*mask))
-     n = float(N.add.reduce(N.ravel(mask)))
-     return sd/math.sqrt(n)
-
-
-#####################################
-############  AMOMENTS  #############
-#####################################
-
- def amoment(a,moment=1,dimension=None):
-    """
-Calculates the nth moment about the mean for a sample (defaults to the
-1st moment).  Generally used to calculate coefficients of skewness and
-kurtosis.  Dimension can equal None (ravel array first), an integer
-(the dimension over which to operate), or a sequence (operate over
-multiple dimensions).
-
-Usage:   amoment(a,moment=1,dimension=None)
-Returns: appropriate moment along given dimension
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    if moment == 1:
-        return 0.0
-    else:
-        mn = amean(a,dimension,1)  # 1=keepdims
-        s = N.power((a-mn),moment)
-        return amean(s,dimension)
-
-
- def avariation(a,dimension=None):
-    """
-Returns the coefficient of variation, as defined in CRC Standard
-Probability and Statistics, p.6. Dimension can equal None (ravel array
-first), an integer (the dimension over which to operate), or a
-sequence (operate over multiple dimensions).
-
-Usage:   avariation(a,dimension=None)
-"""
-    return 100.0*asamplestdev(a,dimension)/amean(a,dimension)
-
-
- def askew(a,dimension=None):
-    """
-Returns the skewness of a distribution (normal ==> 0.0; >0 means extra
-weight in left tail).  Use askewtest() to see if it's close enough.
-Dimension can equal None (ravel array first), an integer (the
-dimension over which to operate), or a sequence (operate over multiple
-dimensions).
-
-Usage:   askew(a, dimension=None)
-Returns: skew of vals in a along dimension, returning ZERO where all vals equal
-"""
-    denom = N.power(amoment(a,2,dimension),1.5)
-    zero = N.equal(denom,0)
-    if type(denom) == N.ndarray and asum(zero) <> 0:
-        print "Number of zeros in askew: ",asum(zero)
-    denom = denom + zero  # prevent divide-by-zero
-    return N.where(zero, 0, amoment(a,3,dimension)/denom)
-
-
- def akurtosis(a,dimension=None):
-    """
-Returns the kurtosis of a distribution (normal ==> 3.0; >3 means
-heavier in the tails, and usually more peaked).  Use akurtosistest()
-to see if it's close enough.  Dimension can equal None (ravel array
-first), an integer (the dimension over which to operate), or a
-sequence (operate over multiple dimensions).
-
-Usage:   akurtosis(a,dimension=None)
-Returns: kurtosis of values in a along dimension, and ZERO where all vals equal
-"""
-    denom = N.power(amoment(a,2,dimension),2)
-    zero = N.equal(denom,0)
-    if type(denom) == N.ndarray and asum(zero) <> 0:
-        print "Number of zeros in akurtosis: ",asum(zero)
-    denom = denom + zero  # prevent divide-by-zero
-    return N.where(zero,0,amoment(a,4,dimension)/denom)
-
-
- def adescribe(inarray,dimension=None):
-     """
-Returns several descriptive statistics of the passed array.  Dimension
-can equal None (ravel array first), an integer (the dimension over
-which to operate), or a sequence (operate over multiple dimensions).
-
-Usage:   adescribe(inarray,dimension=None)
-Returns: n, (min,max), mean, standard deviation, skew, kurtosis
-"""
-     if dimension == None:
-         inarray = N.ravel(inarray)
-         dimension = 0
-     n = inarray.shape[dimension]
-     mm = (N.minimum.reduce(inarray),N.maximum.reduce(inarray))
-     m = amean(inarray,dimension)
-     sd = astdev(inarray,dimension)
-     skew = askew(inarray,dimension)
-     kurt = akurtosis(inarray,dimension)
-     return n, mm, m, sd, skew, kurt
-
-
-#####################################
-########  NORMALITY TESTS  ##########
-#####################################
-
- def askewtest(a,dimension=None):
-    """
-Tests whether the skew is significantly different from a normal
-distribution.  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions).
-
-Usage:   askewtest(a,dimension=None)
-Returns: z-score and 2-tail z-probability
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    b2 = askew(a,dimension)
-    n = float(a.shape[dimension])
-    y = b2 * N.sqrt(((n+1)*(n+3)) / (6.0*(n-2)) )
-    beta2 = ( 3.0*(n*n+27*n-70)*(n+1)*(n+3) ) / ( (n-2.0)*(n+5)*(n+7)*(n+9) )
-    W2 = -1 + N.sqrt(2*(beta2-1))
-    delta = 1/N.sqrt(N.log(N.sqrt(W2)))
-    alpha = N.sqrt(2/(W2-1))
-    y = N.where(y==0,1,y)
-    Z = delta*N.log(y/alpha + N.sqrt((y/alpha)**2+1))
-    return Z, (1.0-zprob(Z))*2
-
-
- def akurtosistest(a,dimension=None):
-    """
-Tests whether a dataset has normal kurtosis (i.e.,
-kurtosis=3(n-1)/(n+1)) Valid only for n>20.  Dimension can equal None
-(ravel array first), an integer (the dimension over which to operate),
-or a sequence (operate over multiple dimensions).
-
-Usage:   akurtosistest(a,dimension=None)
-Returns: z-score and 2-tail z-probability, returns 0 for bad pixels
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    n = float(a.shape[dimension])
-    if n<20:
-        print "akurtosistest only valid for n>=20 ... continuing anyway, n=",n
-    b2 = akurtosis(a,dimension)
-    E = 3.0*(n-1) /(n+1)
-    varb2 = 24.0*n*(n-2)*(n-3) / ((n+1)*(n+1)*(n+3)*(n+5))
-    x = (b2-E)/N.sqrt(varb2)
-    sqrtbeta1 = 6.0*(n*n-5*n+2)/((n+7)*(n+9)) * N.sqrt((6.0*(n+3)*(n+5))/
-                                                       (n*(n-2)*(n-3)))
-    A = 6.0 + 8.0/sqrtbeta1 *(2.0/sqrtbeta1 + N.sqrt(1+4.0/(sqrtbeta1**2)))
-    term1 = 1 -2/(9.0*A)
-    denom = 1 +x*N.sqrt(2/(A-4.0))
-    denom = N.where(N.less(denom,0), 99, denom)
-    term2 = N.where(N.equal(denom,0), term1, N.power((1-2.0/A)/denom,1/3.0))
-    Z = ( term1 - term2 ) / N.sqrt(2/(9.0*A))
-    Z = N.where(N.equal(denom,99), 0, Z)
-    return Z, (1.0-zprob(Z))*2
-
-
- def anormaltest(a,dimension=None):
-    """
-Tests whether skew and/OR kurtosis of dataset differs from normal
-curve.  Can operate over multiple dimensions.  Dimension can equal
-None (ravel array first), an integer (the dimension over which to
-operate), or a sequence (operate over multiple dimensions).
-
-Usage:   anormaltest(a,dimension=None)
-Returns: z-score and 2-tail probability
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    s,p = askewtest(a,dimension)
-    k,p = akurtosistest(a,dimension)
-    k2 = N.power(s,2) + N.power(k,2)
-    return k2, achisqprob(k2,2)
-
-
-#####################################
-######  AFREQUENCY FUNCTIONS  #######
-#####################################
-
- def aitemfreq(a):
-    """
-Returns a 2D array of item frequencies.  Column 1 contains item values,
-column 2 contains their respective counts.  Assumes a 1D array is passed.
-@@@sorting OK?
-
-Usage:   aitemfreq(a)
-Returns: a 2D frequency table (col [0:n-1]=scores, col n=frequencies)
-"""
-    scores = pstat.aunique(a)
-    scores = N.sort(scores)
-    freq = N.zeros(len(scores))
-    for i in range(len(scores)):
-        freq[i] = N.add.reduce(N.equal(a,scores[i]))
-    return N.array(pstat.aabut(scores, freq))
-
-
- def ascoreatpercentile (inarray, percent):
-    """
-Usage:   ascoreatpercentile(inarray,percent)   0<percent<100
-Returns: score at given percentile, relative to inarray distribution
-"""
-    percent = percent / 100.0
-    targetcf = percent*len(inarray)
-    h, lrl, binsize, extras = histogram(inarray)
-    cumhist = cumsum(h*1)
-    for i in range(len(cumhist)):
-        if cumhist[i] >= targetcf:
-            break
-    score = binsize * ((targetcf - cumhist[i-1]) / float(h[i])) + (lrl+binsize*i)
-    return score
-
-
- def apercentileofscore (inarray,score,histbins=10,defaultlimits=None):
-    """
-Note: result of this function depends on the values used to histogram
-the data(!).
-
-Usage:   apercentileofscore(inarray,score,histbins=10,defaultlimits=None)
-Returns: percentile-position of score (0-100) relative to inarray
-"""
-    h, lrl, binsize, extras = histogram(inarray,histbins,defaultlimits)
-    cumhist = cumsum(h*1)
-    i = int((score - lrl)/float(binsize))
-    pct = (cumhist[i-1]+((score-(lrl+binsize*i))/float(binsize))*h[i])/float(len(inarray)) * 100
-    return pct
-
-
- def ahistogram (inarray,numbins=10,defaultlimits=None,printextras=1):
-    """
-Returns (i) an array of histogram bin counts, (ii) the smallest value
-of the histogram binning, and (iii) the bin width (the last 2 are not
-necessarily integers).  Default number of bins is 10.  Defaultlimits
-can be None (the routine picks bins spanning all the numbers in the
-inarray) or a 2-sequence (lowerlimit, upperlimit).  Returns all of the
-following: array of bin values, lowerreallimit, binsize, extrapoints.
-
-Usage:   ahistogram(inarray,numbins=10,defaultlimits=None,printextras=1)
-Returns: (array of bin counts, bin-minimum, min-width, #-points-outside-range)
-"""
-    inarray = N.ravel(inarray)               # flatten any >1D arrays
-    if (defaultlimits <> None):
-        lowerreallimit = defaultlimits[0]
-        upperreallimit = defaultlimits[1]
-        binsize = (upperreallimit-lowerreallimit) / float(numbins)
-    else:
-        Min = N.minimum.reduce(inarray)
-        Max = N.maximum.reduce(inarray)
-        estbinwidth = float(Max - Min)/float(numbins) + 1e-6
-        binsize = (Max-Min+estbinwidth)/float(numbins)
-        lowerreallimit = Min - binsize/2.0  #lower real limit,1st bin
-    bins = N.zeros(numbins)
-    extrapoints = 0
-    for num in inarray:
-        try:
-            if (num-lowerreallimit) < 0:
-                extrapoints = extrapoints + 1
-            else:
-                bintoincrement = int((num-lowerreallimit) / float(binsize))
-                bins[bintoincrement] = bins[bintoincrement] + 1
-        except:                           # point outside lower/upper limits
-            extrapoints = extrapoints + 1
-    if (extrapoints > 0 and printextras == 1):
-        print '\nPoints outside given histogram range =',extrapoints
-    return (bins, lowerreallimit, binsize, extrapoints)
-
-
- def acumfreq(a,numbins=10,defaultreallimits=None):
-    """
-Returns a cumulative frequency histogram, using the histogram function.
-Defaultreallimits can be None (use all data), or a 2-sequence containing
-lower and upper limits on values to include.
-
-Usage:   acumfreq(a,numbins=10,defaultreallimits=None)
-Returns: array of cumfreq bin values, lowerreallimit, binsize, extrapoints
-"""
-    h,l,b,e = histogram(a,numbins,defaultreallimits)
-    cumhist = cumsum(h*1)
-    return cumhist,l,b,e
-
-
- def arelfreq(a,numbins=10,defaultreallimits=None):
-    """
-Returns a relative frequency histogram, using the histogram function.
-Defaultreallimits can be None (use all data), or a 2-sequence containing
-lower and upper limits on values to include.
-
-Usage:   arelfreq(a,numbins=10,defaultreallimits=None)
-Returns: array of cumfreq bin values, lowerreallimit, binsize, extrapoints
-"""
-    h,l,b,e = histogram(a,numbins,defaultreallimits)
-    h = N.array(h/float(a.shape[0]))
-    return h,l,b,e
-
-
-#####################################
-######  AVARIABILITY FUNCTIONS  #####
-#####################################
-
- def aobrientransform(*args):
-    """
-Computes a transform on input data (any number of columns).  Used to
-test for homogeneity of variance prior to running one-way stats.  Each
-array in *args is one level of a factor.  If an F_oneway() run on the
-transformed data and found significant, variances are unequal.   From
-Maxwell and Delaney, p.112.
-
-Usage:   aobrientransform(*args)    *args = 1D arrays, one per level of factor
-Returns: transformed data for use in an ANOVA
-"""
-    TINY = 1e-10
-    k = len(args)
-    n = N.zeros(k,N.float_)
-    v = N.zeros(k,N.float_)
-    m = N.zeros(k,N.float_)
-    nargs = []
-    for i in range(k):
-        nargs.append(args[i].astype(N.float_))
-        n[i] = float(len(nargs[i]))
-        v[i] = var(nargs[i])
-        m[i] = mean(nargs[i])
-    for j in range(k):
-        for i in range(n[j]):
-            t1 = (n[j]-1.5)*n[j]*(nargs[j][i]-m[j])**2
-            t2 = 0.5*v[j]*(n[j]-1.0)
-            t3 = (n[j]-1.0)*(n[j]-2.0)
-            nargs[j][i] = (t1-t2) / float(t3)
-    check = 1
-    for j in range(k):
-        if v[j] - mean(nargs[j]) > TINY:
-            check = 0
-    if check <> 1:
-        raise ValueError, 'Lack of convergence in obrientransform.'
-    else:
-        return N.array(nargs)
-
-
- def asamplevar (inarray,dimension=None,keepdims=0):
-    """
-Returns the sample standard deviation of the values in the passed
-array (i.e., using N).  Dimension can equal None (ravel array first),
-an integer (the dimension over which to operate), or a sequence
-(operate over multiple dimensions).  Set keepdims=1 to return an array
-with the same number of dimensions as inarray.
-
-Usage:   asamplevar(inarray,dimension=None,keepdims=0)
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    if dimension == 1:
-        mn = amean(inarray,dimension)[:,N.NewAxis]
-    else:
-        mn = amean(inarray,dimension,keepdims=1)
-    deviations = inarray - mn
-    if type(dimension) == ListType:
-        n = 1
-        for d in dimension:
-            n = n*inarray.shape[d]
-    else:
-        n = inarray.shape[dimension]
-    svar = ass(deviations,dimension,keepdims) / float(n)
-    return svar
-
-
- def asamplestdev (inarray, dimension=None, keepdims=0):
-    """
-Returns the sample standard deviation of the values in the passed
-array (i.e., using N).  Dimension can equal None (ravel array first),
-an integer (the dimension over which to operate), or a sequence
-(operate over multiple dimensions).  Set keepdims=1 to return an array
-with the same number of dimensions as inarray.
-
-Usage:   asamplestdev(inarray,dimension=None,keepdims=0)
-"""
-    return N.sqrt(asamplevar(inarray,dimension,keepdims))
-
-
- def asignaltonoise(instack,dimension=0):
-    """
-Calculates signal-to-noise.  Dimension can equal None (ravel array
-first), an integer (the dimension over which to operate), or a
-sequence (operate over multiple dimensions).
-
-Usage:   asignaltonoise(instack,dimension=0):
-Returns: array containing the value of (mean/stdev) along dimension,
-         or 0 when stdev=0
-"""
-    m = mean(instack,dimension)
-    sd = stdev(instack,dimension)
-    return N.where(sd==0,0,m/sd)
-
-
- def acov (x,y, dimension=None,keepdims=0):
-    """
-Returns the estimated covariance of the values in the passed
-array (i.e., N-1).  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions).  Set keepdims=1 to return an array with the
-same number of dimensions as inarray.
-
-Usage:   acov(x,y,dimension=None,keepdims=0)
-"""
-    if dimension == None:
-        x = N.ravel(x)
-        y = N.ravel(y)
-        dimension = 0
-    xmn = amean(x,dimension,1)  # keepdims
-    xdeviations = x - xmn
-    ymn = amean(y,dimension,1)  # keepdims
-    ydeviations = y - ymn
-    if type(dimension) == ListType:
-        n = 1
-        for d in dimension:
-            n = n*x.shape[d]
-    else:
-        n = x.shape[dimension]
-    covar = N.sum(xdeviations*ydeviations)/float(n-1)
-    return covar
-
-
- def avar (inarray, dimension=None,keepdims=0):
-    """
-Returns the estimated population variance of the values in the passed
-array (i.e., N-1).  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions).  Set keepdims=1 to return an array with the
-same number of dimensions as inarray.
-
-Usage:   avar(inarray,dimension=None,keepdims=0)
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    mn = amean(inarray,dimension,1)
-    deviations = inarray - mn
-    if type(dimension) == ListType:
-        n = 1
-        for d in dimension:
-            n = n*inarray.shape[d]
-    else:
-        n = inarray.shape[dimension]
-    var = ass(deviations,dimension,keepdims)/float(n-1)
-    return var
-
-
- def astdev (inarray, dimension=None, keepdims=0):
-    """
-Returns the estimated population standard deviation of the values in
-the passed array (i.e., N-1).  Dimension can equal None (ravel array
-first), an integer (the dimension over which to operate), or a
-sequence (operate over multiple dimensions).  Set keepdims=1 to return
-an array with the same number of dimensions as inarray.
-
-Usage:   astdev(inarray,dimension=None,keepdims=0)
-"""
-    return N.sqrt(avar(inarray,dimension,keepdims))
-
-
- def asterr (inarray, dimension=None, keepdims=0):
-    """
-Returns the estimated population standard error of the values in the
-passed array (i.e., N-1).  Dimension can equal None (ravel array
-first), an integer (the dimension over which to operate), or a
-sequence (operate over multiple dimensions).  Set keepdims=1 to return
-an array with the same number of dimensions as inarray.
-
-Usage:   asterr(inarray,dimension=None,keepdims=0)
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    return astdev(inarray,dimension,keepdims) / float(N.sqrt(inarray.shape[dimension]))
-
-
- def asem (inarray, dimension=None, keepdims=0):
-    """
-Returns the standard error of the mean (i.e., using N) of the values
-in the passed array.  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions).  Set keepdims=1 to return an array with the
-same number of dimensions as inarray.
-
-Usage:   asem(inarray,dimension=None, keepdims=0)
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    if type(dimension) == ListType:
-        n = 1
-        for d in dimension:
-            n = n*inarray.shape[d]
-    else:
-        n = inarray.shape[dimension]
-    s = asamplestdev(inarray,dimension,keepdims) / N.sqrt(n-1)
-    return s
-
-
- def az (a, score):
-    """
-Returns the z-score of a given input score, given thearray from which
-that score came.  Not appropriate for population calculations, nor for
-arrays > 1D.
-
-Usage:   az(a, score)
-"""
-    z = (score-amean(a)) / asamplestdev(a)
-    return z
-
-
- def azs (a):
-    """
-Returns a 1D array of z-scores, one for each score in the passed array,
-computed relative to the passed array.
-
-Usage:   azs(a)
-"""
-    zscores = []
-    for item in a:
-        zscores.append(z(a,item))
-    return N.array(zscores)
-
-
- def azmap (scores, compare, dimension=0):
-    """
-Returns an array of z-scores the shape of scores (e.g., [x,y]), compared to
-array passed to compare (e.g., [time,x,y]).  Assumes collapsing over dim 0
-of the compare array.
-
-Usage:   azs(scores, compare, dimension=0)
-"""
-    mns = amean(compare,dimension)
-    sstd = asamplestdev(compare,0)
-    return (scores - mns) / sstd
-
-
-#####################################
-#######  ATRIMMING FUNCTIONS  #######
-#####################################
-
-## deleted around() as it's in numpy now
-
- def athreshold(a,threshmin=None,threshmax=None,newval=0):
-    """
-Like Numeric.clip() except that values <threshmid or >threshmax are replaced
-by newval instead of by threshmin/threshmax (respectively).
-
-Usage:   athreshold(a,threshmin=None,threshmax=None,newval=0)
-Returns: a, with values <threshmin or >threshmax replaced with newval
-"""
-    mask = N.zeros(a.shape)
-    if threshmin <> None:
-        mask = mask + N.where(a<threshmin,1,0)
-    if threshmax <> None:
-        mask = mask + N.where(a>threshmax,1,0)
-    mask = N.clip(mask,0,1)
-    return N.where(mask,newval,a)
-
-
- def atrimboth (a,proportiontocut):
-    """
-Slices off the passed proportion of items from BOTH ends of the passed
-array (i.e., with proportiontocut=0.1, slices 'leftmost' 10% AND
-'rightmost' 10% of scores.  You must pre-sort the array if you want
-"proper" trimming.  Slices off LESS if proportion results in a
-non-integer slice index (i.e., conservatively slices off
-proportiontocut).
-
-Usage:   atrimboth (a,proportiontocut)
-Returns: trimmed version of array a
-"""
-    lowercut = int(proportiontocut*len(a))
-    uppercut = len(a) - lowercut
-    return a[lowercut:uppercut]
-
-
- def atrim1 (a,proportiontocut,tail='right'):
-    """
-Slices off the passed proportion of items from ONE end of the passed
-array (i.e., if proportiontocut=0.1, slices off 'leftmost' or 'rightmost'
-10% of scores).  Slices off LESS if proportion results in a non-integer
-slice index (i.e., conservatively slices off proportiontocut).
-
-Usage:   atrim1(a,proportiontocut,tail='right')  or set tail='left'
-Returns: trimmed version of array a
-"""
-    if string.lower(tail) == 'right':
-        lowercut = 0
-        uppercut = len(a) - int(proportiontocut*len(a))
-    elif string.lower(tail) == 'left':
-        lowercut = int(proportiontocut*len(a))
-        uppercut = len(a)
-    return a[lowercut:uppercut]
-
-
-#####################################
-#####  ACORRELATION FUNCTIONS  ######
-#####################################
-
- def acovariance(X):
-    """
-Computes the covariance matrix of a matrix X.  Requires a 2D matrix input.
-
-Usage:   acovariance(X)
-Returns: covariance matrix of X
-"""
-    if len(X.shape) <> 2:
-        raise TypeError, "acovariance requires 2D matrices"
-    n = X.shape[0]
-    mX = amean(X,0)
-    return N.dot(N.transpose(X),X) / float(n) - N.multiply.outer(mX,mX)
-
-
- def acorrelation(X):
-    """
-Computes the correlation matrix of a matrix X.  Requires a 2D matrix input.
-
-Usage:   acorrelation(X)
-Returns: correlation matrix of X
-"""
-    C = acovariance(X)
-    V = N.diagonal(C)
-    return C / N.sqrt(N.multiply.outer(V,V))
-
-
- def apaired(x,y):
-    """
-Interactively determines the type of data in x and y, and then runs the
-appropriated statistic for paired group data.
-
-Usage:   apaired(x,y)     x,y = the two arrays of values to be compared
-Returns: appropriate statistic name, value, and probability
-"""
-    samples = ''
-    while samples not in ['i','r','I','R','c','C']:
-        print '\nIndependent or related samples, or correlation (i,r,c): ',
-        samples = raw_input()
-
-    if samples in ['i','I','r','R']:
-        print '\nComparing variances ...',
-# USE O'BRIEN'S TEST FOR HOMOGENEITY OF VARIANCE, Maxwell & delaney, p.112
-        r = obrientransform(x,y)
-        f,p = F_oneway(pstat.colex(r,0),pstat.colex(r,1))
-        if p<0.05:
-            vartype='unequal, p='+str(round(p,4))
-        else:
-            vartype='equal'
-        print vartype
-        if samples in ['i','I']:
-            if vartype[0]=='e':
-                t,p = ttest_ind(x,y,None,0)
-                print '\nIndependent samples t-test:  ', round(t,4),round(p,4)
-            else:
-                if len(x)>20 or len(y)>20:
-                    z,p = ranksums(x,y)
-                    print '\nRank Sums test (NONparametric, n>20):  ', round(z,4),round(p,4)
-                else:
-                    u,p = mannwhitneyu(x,y)
-                    print '\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u,4),round(p,4)
-
-        else:  # RELATED SAMPLES
-            if vartype[0]=='e':
-                t,p = ttest_rel(x,y,0)
-                print '\nRelated samples t-test:  ', round(t,4),round(p,4)
-            else:
-                t,p = ranksums(x,y)
-                print '\nWilcoxon T-test (NONparametric):  ', round(t,4),round(p,4)
-    else:  # CORRELATION ANALYSIS
-        corrtype = ''
-        while corrtype not in ['c','C','r','R','d','D']:
-            print '\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ',
-            corrtype = raw_input()
-        if corrtype in ['c','C']:
-            m,b,r,p,see = linregress(x,y)
-            print '\nLinear regression for continuous variables ...'
-            lol = [['Slope','Intercept','r','Prob','SEestimate'],[round(m,4),round(b,4),round(r,4),round(p,4),round(see,4)]]
-            pstat.printcc(lol)
-        elif corrtype in ['r','R']:
-            r,p = spearmanr(x,y)
-            print '\nCorrelation for ranked variables ...'
-            print "Spearman's r: ",round(r,4),round(p,4)
-        else: # DICHOTOMOUS
-            r,p = pointbiserialr(x,y)
-            print '\nAssuming x contains a dichotomous variable ...'
-            print 'Point Biserial r: ',round(r,4),round(p,4)
-    print '\n\n'
-    return None
-
-
- def dices(x,y):
-    """
-Calculates Dice's coefficient ... (2*number of common terms)/(number of terms in x +
-number of terms in y). Returns a value between 0 (orthogonal) and 1.
-
-Usage:  dices(x,y)
-"""
-    import sets
-    x = sets.Set(x)
-    y = sets.Set(y)
-    common = len(x.intersection(y))
-    total = float(len(x) + len(y))
-    return 2*common/total
-
-
- def icc(x,y=None,verbose=0):
-    """
-Calculates intraclass correlation coefficients using simple, Type I sums of squares.
-If only one variable is passed, assumed it's an Nx2 matrix
-
-Usage:   icc(x,y=None,verbose=0)
-Returns: icc rho, prob ####PROB IS A GUESS BASED ON PEARSON
-"""
-    TINY = 1.0e-20
-    if y:
-        all = N.concatenate([x,y],0)
-    else:
-        all = x+0
-        x = all[:,0]
-        y = all[:,1]
-    totalss = ass(all-mean(all))
-    pairmeans = (x+y)/2.
-    withinss = ass(x-pairmeans) + ass(y-pairmeans)
-    withindf = float(len(x))
-    betwdf = float(len(x)-1)
-    withinms = withinss / withindf
-    betweenms = (totalss-withinss) / betwdf
-    rho = (betweenms-withinms)/(withinms+betweenms)
-    t = rho*math.sqrt(betwdf/((1.0-rho+TINY)*(1.0+rho+TINY)))
-    prob = abetai(0.5*betwdf,0.5,betwdf/(betwdf+t*t),verbose)
-    return rho, prob
-
-
- def alincc(x,y):
-    """
-Calculates Lin's concordance correlation coefficient.
-
-Usage:   alincc(x,y)    where x, y are equal-length arrays
-Returns: Lin's CC
-"""
-    x = N.ravel(x)
-    y = N.ravel(y)
-    covar = acov(x,y)*(len(x)-1)/float(len(x))  # correct denom to n
-    xvar = avar(x)*(len(x)-1)/float(len(x))  # correct denom to n
-    yvar = avar(y)*(len(y)-1)/float(len(y))  # correct denom to n
-    lincc = (2 * covar) / ((xvar+yvar) +((amean(x)-amean(y))**2))
-    return lincc
-
-
- def apearsonr(x,y,verbose=1):
-    """
-Calculates a Pearson correlation coefficient and returns p.  Taken
-from Heiman's Basic Statistics for the Behav. Sci (2nd), p.195.
-
-Usage:   apearsonr(x,y,verbose=1)      where x,y are equal length arrays
-Returns: Pearson's r, two-tailed p-value
-"""
-    TINY = 1.0e-20
-    n = len(x)
-    xmean = amean(x)
-    ymean = amean(y)
-    r_num = n*(N.add.reduce(x*y)) - N.add.reduce(x)*N.add.reduce(y)
-    r_den = math.sqrt((n*ass(x) - asquare_of_sums(x))*(n*ass(y)-asquare_of_sums(y)))
-    r = (r_num / r_den)
-    df = n-2
-    t = r*math.sqrt(df/((1.0-r+TINY)*(1.0+r+TINY)))
-    prob = abetai(0.5*df,0.5,df/(df+t*t),verbose)
-    return r,prob
-
-
- def aspearmanr(x,y):
-    """
-Calculates a Spearman rank-order correlation coefficient.  Taken
-from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.
-
-Usage:   aspearmanr(x,y)      where x,y are equal-length arrays
-Returns: Spearman's r, two-tailed p-value
-"""
-    TINY = 1e-30
-    n = len(x)
-    rankx = rankdata(x)
-    ranky = rankdata(y)
-    dsq = N.add.reduce((rankx-ranky)**2)
-    rs = 1 - 6*dsq / float(n*(n**2-1))
-    t = rs * math.sqrt((n-2) / ((rs+1.0)*(1.0-rs)))
-    df = n-2
-    probrs = abetai(0.5*df,0.5,df/(df+t*t))
-# probability values for rs are from part 2 of the spearman function in
-# Numerical Recipies, p.510.  They close to tables, but not exact.(?)
-    return rs, probrs
-
-
- def apointbiserialr(x,y):
-    """
-Calculates a point-biserial correlation coefficient and the associated
-probability value.  Taken from Heiman's Basic Statistics for the Behav.
-Sci (1st), p.194.
-
-Usage:   apointbiserialr(x,y)      where x,y are equal length arrays
-Returns: Point-biserial r, two-tailed p-value
-"""
-    TINY = 1e-30
-    categories = pstat.aunique(x)
-    data = pstat.aabut(x,y)
-    if len(categories) <> 2:
-        raise ValueError, "Exactly 2 categories required (in x) for pointbiserialr()."
-    else:   # there are 2 categories, continue
-        codemap = pstat.aabut(categories,N.arange(2))
-        recoded = pstat.arecode(data,codemap,0)
-        x = pstat.alinexand(data,0,categories[0])
-        y = pstat.alinexand(data,0,categories[1])
-        xmean = amean(pstat.acolex(x,1))
-        ymean = amean(pstat.acolex(y,1))
-        n = len(data)
-        adjust = math.sqrt((len(x)/float(n))*(len(y)/float(n)))
-        rpb = (ymean - xmean)/asamplestdev(pstat.acolex(data,1))*adjust
-        df = n-2
-        t = rpb*math.sqrt(df/((1.0-rpb+TINY)*(1.0+rpb+TINY)))
-        prob = abetai(0.5*df,0.5,df/(df+t*t))
-        return rpb, prob
-
-
- def akendalltau(x,y):
-    """
-Calculates Kendall's tau ... correlation of ordinal data.  Adapted
-from function kendl1 in Numerical Recipies.  Needs good test-cases.@@@
-
-Usage:   akendalltau(x,y)
-Returns: Kendall's tau, two-tailed p-value
-"""
-    n1 = 0
-    n2 = 0
-    iss = 0
-    for j in range(len(x)-1):
-        for k in range(j,len(y)):
-            a1 = x[j] - x[k]
-            a2 = y[j] - y[k]
-            aa = a1 * a2
-            if (aa):             # neither array has a tie
-                n1 = n1 + 1
-                n2 = n2 + 1
-                if aa > 0:
-                    iss = iss + 1
-                else:
-                    iss = iss -1
-            else:
-                if (a1):
-                    n1 = n1 + 1
-                else:
-                    n2 = n2 + 1
-    tau = iss / math.sqrt(n1*n2)
-    svar = (4.0*len(x)+10.0) / (9.0*len(x)*(len(x)-1))
-    z = tau / math.sqrt(svar)
-    prob = erfcc(abs(z)/1.4142136)
-    return tau, prob
-
-
- def alinregress(*args):
-    """
-Calculates a regression line on two arrays, x and y, corresponding to x,y
-pairs.  If a single 2D array is passed, alinregress finds dim with 2 levels
-and splits data into x,y pairs along that dim.
-
-Usage:   alinregress(*args)    args=2 equal-length arrays, or one 2D array
-Returns: slope, intercept, r, two-tailed prob, sterr-of-the-estimate, n
-"""
-    TINY = 1.0e-20
-    if len(args) == 1:  # more than 1D array?
-        args = args[0]
-        if len(args) == 2:
-            x = args[0]
-            y = args[1]
-        else:
-            x = args[:,0]
-            y = args[:,1]
-    else:
-        x = args[0]
-        y = args[1]
-    n = len(x)
-    xmean = amean(x)
-    ymean = amean(y)
-    r_num = n*(N.add.reduce(x*y)) - N.add.reduce(x)*N.add.reduce(y)
-    r_den = math.sqrt((n*ass(x) - asquare_of_sums(x))*(n*ass(y)-asquare_of_sums(y)))
-    r = r_num / r_den
-    z = 0.5*math.log((1.0+r+TINY)/(1.0-r+TINY))
-    df = n-2
-    t = r*math.sqrt(df/((1.0-r+TINY)*(1.0+r+TINY)))
-    prob = abetai(0.5*df,0.5,df/(df+t*t))
-    slope = r_num / (float(n)*ass(x) - asquare_of_sums(x))
-    intercept = ymean - slope*xmean
-    sterrest = math.sqrt(1-r*r)*asamplestdev(y)
-    return slope, intercept, r, prob, sterrest, n
-
- def amasslinregress(*args):
-    """
-Calculates a regression line on one 1D array (x) and one N-D array (y).
-
-Returns: slope, intercept, r, two-tailed prob, sterr-of-the-estimate, n
-"""
-    TINY = 1.0e-20
-    if len(args) == 1:  # more than 1D array?
-        args = args[0]
-        if len(args) == 2:
-            x = N.ravel(args[0])
-            y = args[1]
-        else:
-            x = N.ravel(args[:,0])
-            y = args[:,1]
-    else:
-        x = args[0]
-        y = args[1]
-    x = x.astype(N.float_)
-    y = y.astype(N.float_)
-    n = len(x)
-    xmean = amean(x)
-    ymean = amean(y,0)
-    shp = N.ones(len(y.shape))
-    shp[0] = len(x)
-    x.shape = shp
-    print x.shape, y.shape
-    r_num = n*(N.add.reduce(x*y,0)) - N.add.reduce(x)*N.add.reduce(y,0)
-    r_den = N.sqrt((n*ass(x) - asquare_of_sums(x))*(n*ass(y,0)-asquare_of_sums(y,0)))
-    zerodivproblem = N.equal(r_den,0)
-    r_den = N.where(zerodivproblem,1,r_den)  # avoid zero-division in 1st place
-    r = r_num / r_den  # need to do this nicely for matrix division
-    r = N.where(zerodivproblem,0.0,r)
-    z = 0.5*N.log((1.0+r+TINY)/(1.0-r+TINY))
-    df = n-2
-    t = r*N.sqrt(df/((1.0-r+TINY)*(1.0+r+TINY)))
-    prob = abetai(0.5*df,0.5,df/(df+t*t))
-
-    ss = float(n)*ass(x)-asquare_of_sums(x)
-    s_den = N.where(ss==0,1,ss)  # avoid zero-division in 1st place
-    slope = r_num / s_den
-    intercept = ymean - slope*xmean
-    sterrest = N.sqrt(1-r*r)*asamplestdev(y,0)
-    return slope, intercept, r, prob, sterrest, n
-
-
-#####################################
-#####  AINFERENTIAL STATISTICS  #####
-#####################################
-
- def attest_1samp(a,popmean,printit=0,name='Sample',writemode='a'):
-    """
-Calculates the t-obtained for the independent samples T-test on ONE group
-of scores a, given a population mean.  If printit=1, results are printed
-to the screen.  If printit='filename', the results are output to 'filename'
-using the given writemode (default=append).  Returns t-value, and prob.
-
-Usage:   attest_1samp(a,popmean,Name='Sample',printit=0,writemode='a')
-Returns: t-value, two-tailed prob
-"""
-    if type(a) != N.ndarray:
-        a = N.array(a)
-    x = amean(a)
-    v = avar(a)
-    n = len(a)
-    df = n-1
-    svar = ((n-1)*v) / float(df)
-    t = (x-popmean)/math.sqrt(svar*(1.0/n))
-    prob = abetai(0.5*df,0.5,df/(df+t*t))
-
-    if printit <> 0:
-        statname = 'Single-sample T-test.'
-        outputpairedstats(printit,writemode,
-                          'Population','--',popmean,0,0,0,
-                          name,n,x,v,N.minimum.reduce(N.ravel(a)),
-                          N.maximum.reduce(N.ravel(a)),
-                          statname,t,prob)
-    return t,prob
-
-
- def attest_ind (a, b, dimension=None, printit=0, name1='Samp1', name2='Samp2',writemode='a'):
-    """
-Calculates the t-obtained T-test on TWO INDEPENDENT samples of scores
-a, and b.  From Numerical Recipies, p.483.  If printit=1, results are
-printed to the screen.  If printit='filename', the results are output
-to 'filename' using the given writemode (default=append).  Dimension
-can equal None (ravel array first), or an integer (the dimension over
-which to operate on a and b).
-
-Usage:   attest_ind (a,b,dimension=None,printit=0,
-                     Name1='Samp1',Name2='Samp2',writemode='a')
-Returns: t-value, two-tailed p-value
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        b = N.ravel(b)
-        dimension = 0
-    x1 = amean(a,dimension)
-    x2 = amean(b,dimension)
-    v1 = avar(a,dimension)
-    v2 = avar(b,dimension)
-    n1 = a.shape[dimension]
-    n2 = b.shape[dimension]
-    df = n1+n2-2
-    svar = ((n1-1)*v1+(n2-1)*v2) / float(df)
-    zerodivproblem = N.equal(svar,0)
-    svar = N.where(zerodivproblem,1,svar)  # avoid zero-division in 1st place
-    t = (x1-x2)/N.sqrt(svar*(1.0/n1 + 1.0/n2))  # N-D COMPUTATION HERE!!!!!!
-    t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
-    probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
-
-    if type(t) == N.ndarray:
-        probs = N.reshape(probs,t.shape)
-    if probs.shape == (1,):
-        probs = probs[0]
-
-    if printit <> 0:
-        if type(t) == N.ndarray:
-            t = t[0]
-        if type(probs) == N.ndarray:
-            probs = probs[0]
-        statname = 'Independent samples T-test.'
-        outputpairedstats(printit,writemode,
-                          name1,n1,x1,v1,N.minimum.reduce(N.ravel(a)),
-                          N.maximum.reduce(N.ravel(a)),
-                          name2,n2,x2,v2,N.minimum.reduce(N.ravel(b)),
-                          N.maximum.reduce(N.ravel(b)),
-                          statname,t,probs)
-        return
-    return t, probs
-
- def ap2t(pval,df):
-    """
-Tries to compute a t-value from a p-value (or pval array) and associated df.
-SLOW for large numbers of elements(!) as it re-computes p-values 20 times
-(smaller step-sizes) at which point it decides it's done. Keeps the signs
-of the input array. Returns 1000 (or -1000) if t>100.
-
-Usage:  ap2t(pval,df)
-Returns: an array of t-values with the shape of pval
-    """
-    pval = N.array(pval)
-    signs = N.sign(pval)
-    pval = abs(pval)
-    t = N.ones(pval.shape,N.float_)*50
-    step = N.ones(pval.shape,N.float_)*25
-    print "Initial ap2t() prob calc"
-    prob = abetai(0.5*df,0.5,float(df)/(df+t*t))
-    print 'ap2t() iter: ',
-    for i in range(10):
-        print i,' ',
-        t = N.where(pval<prob,t+step,t-step)
-        prob = abetai(0.5*df,0.5,float(df)/(df+t*t))
-        step = step/2
-    print
-    # since this is an ugly hack, we get ugly boundaries
-    t = N.where(t>99.9,1000,t)      # hit upper-boundary
-    t = t+signs
-    return t #, prob, pval
-
-
- def attest_rel (a,b,dimension=None,printit=0,name1='Samp1',name2='Samp2',writemode='a'):
-    """
-Calculates the t-obtained T-test on TWO RELATED samples of scores, a
-and b.  From Numerical Recipies, p.483.  If printit=1, results are
-printed to the screen.  If printit='filename', the results are output
-to 'filename' using the given writemode (default=append).  Dimension
-can equal None (ravel array first), or an integer (the dimension over
-which to operate on a and b).
-
-Usage:   attest_rel(a,b,dimension=None,printit=0,
-                    name1='Samp1',name2='Samp2',writemode='a')
-Returns: t-value, two-tailed p-value
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        b = N.ravel(b)
-        dimension = 0
-    if len(a)<>len(b):
-        raise ValueError, 'Unequal length arrays.'
-    x1 = amean(a,dimension)
-    x2 = amean(b,dimension)
-    v1 = avar(a,dimension)
-    v2 = avar(b,dimension)
-    n = a.shape[dimension]
-    df = float(n-1)
-    d = (a-b).astype('d')
-
-    denom = N.sqrt((n*N.add.reduce(d*d,dimension) - N.add.reduce(d,dimension)**2) /df)
-    zerodivproblem = N.equal(denom,0)
-    denom = N.where(zerodivproblem,1,denom)  # avoid zero-division in 1st place
-    t = N.add.reduce(d,dimension) / denom      # N-D COMPUTATION HERE!!!!!!
-    t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
-    probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
-    if type(t) == N.ndarray:
-        probs = N.reshape(probs,t.shape)
-    if probs.shape == (1,):
-        probs = probs[0]
-
-    if printit <> 0:
-        statname = 'Related samples T-test.'
-        outputpairedstats(printit,writemode,
-                          name1,n,x1,v1,N.minimum.reduce(N.ravel(a)),
-                          N.maximum.reduce(N.ravel(a)),
-                          name2,n,x2,v2,N.minimum.reduce(N.ravel(b)),
-                          N.maximum.reduce(N.ravel(b)),
-                          statname,t,probs)
-        return
-    return t, probs
-
-
- def achisquare(f_obs,f_exp=None):
-    """
-Calculates a one-way chi square for array of observed frequencies and returns
-the result.  If no expected frequencies are given, the total N is assumed to
-be equally distributed across all groups.
-@@@NOT RIGHT??
-
-Usage:   achisquare(f_obs, f_exp=None)   f_obs = array of observed cell freq.
-Returns: chisquare-statistic, associated p-value
-"""
-
-    k = len(f_obs)
-    if f_exp == None:
-        f_exp = N.array([sum(f_obs)/float(k)] * len(f_obs),N.float_)
-    f_exp = f_exp.astype(N.float_)
-    chisq = N.add.reduce((f_obs-f_exp)**2 / f_exp)
-    return chisq, achisqprob(chisq, k-1)
-
-
- def aks_2samp (data1,data2):
-    """
-Computes the Kolmogorov-Smirnof statistic on 2 samples.  Modified from
-Numerical Recipies in C, page 493.  Returns KS D-value, prob.  Not ufunc-
-like.
-
-Usage:   aks_2samp(data1,data2)  where data1 and data2 are 1D arrays
-Returns: KS D-value, p-value
-"""
-    j1 = 0    # N.zeros(data1.shape[1:]) TRIED TO MAKE THIS UFUNC-LIKE
-    j2 = 0    # N.zeros(data2.shape[1:])
-    fn1 = 0.0 # N.zeros(data1.shape[1:],N.float_)
-    fn2 = 0.0 # N.zeros(data2.shape[1:],N.float_)
-    n1 = data1.shape[0]
-    n2 = data2.shape[0]
-    en1 = n1*1
-    en2 = n2*1
-    d = N.zeros(data1.shape[1:],N.float_)
-    data1 = N.sort(data1,0)
-    data2 = N.sort(data2,0)
-    while j1 < n1 and j2 < n2:
-        d1=data1[j1]
-        d2=data2[j2]
-        if d1 <= d2:
-            fn1 = (j1)/float(en1)
-            j1 = j1 + 1
-        if d2 <= d1:
-            fn2 = (j2)/float(en2)
-            j2 = j2 + 1
-        dt = (fn2-fn1)
-        if abs(dt) > abs(d):
-            d = dt
-#    try:
-    en = math.sqrt(en1*en2/float(en1+en2))
-    prob = aksprob((en+0.12+0.11/en)*N.fabs(d))
-#    except:
-#        prob = 1.0
-    return d, prob
-
-
- def amannwhitneyu(x,y):
-    """
-Calculates a Mann-Whitney U statistic on the provided scores and
-returns the result.  Use only when the n in each condition is < 20 and
-you have 2 independent samples of ranks.  REMEMBER: Mann-Whitney U is
-significant if the u-obtained is LESS THAN or equal to the critical
-value of U.
-
-Usage:   amannwhitneyu(x,y)     where x,y are arrays of values for 2 conditions
-Returns: u-statistic, one-tailed p-value (i.e., p(z(U)))
-"""
-    n1 = len(x)
-    n2 = len(y)
-    ranked = rankdata(N.concatenate((x,y)))
-    rankx = ranked[0:n1]       # get the x-ranks
-    ranky = ranked[n1:]        # the rest are y-ranks
-    u1 = n1*n2 + (n1*(n1+1))/2.0 - sum(rankx)  # calc U for x
-    u2 = n1*n2 - u1                            # remainder is U for y
-    bigu = max(u1,u2)
-    smallu = min(u1,u2)
-    proportion = bigu/float(n1*n2)
-    T = math.sqrt(tiecorrect(ranked))  # correction factor for tied scores
-    if T == 0:
-        raise ValueError, 'All numbers are identical in amannwhitneyu'
-    sd = math.sqrt(T*n1*n2*(n1+n2+1)/12.0)
-    z = abs((bigu-n1*n2/2.0) / sd)  # normal approximation for prob calc
-    return smallu, 1.0 - azprob(z), proportion
-
-
- def atiecorrect(rankvals):
-    """
-Tie-corrector for ties in Mann Whitney U and Kruskal Wallis H tests.
-See Siegel, S. (1956) Nonparametric Statistics for the Behavioral
-Sciences.  New York: McGraw-Hill.  Code adapted from |Stat rankind.c
-code.
-
-Usage:   atiecorrect(rankvals)
-Returns: T correction factor for U or H
-"""
-    sorted,posn = ashellsort(N.array(rankvals))
-    n = len(sorted)
-    T = 0.0
-    i = 0
-    while (i<n-1):
-        if sorted[i] == sorted[i+1]:
-            nties = 1
-            while (i<n-1) and (sorted[i] == sorted[i+1]):
-                nties = nties +1
-                i = i +1
-            T = T + nties**3 - nties
-        i = i+1
-    T = T / float(n**3-n)
-    return 1.0 - T
-
-
- def aranksums(x,y):
-    """
-Calculates the rank sums statistic on the provided scores and returns
-the result.
-
-Usage:   aranksums(x,y)     where x,y are arrays of values for 2 conditions
-Returns: z-statistic, two-tailed p-value
-"""
-    n1 = len(x)
-    n2 = len(y)
-    alldata = N.concatenate((x,y))
-    ranked = arankdata(alldata)
-    x = ranked[:n1]
-    y = ranked[n1:]
-    s = sum(x)
-    expected = n1*(n1+n2+1) / 2.0
-    z = (s - expected) / math.sqrt(n1*n2*(n1+n2+1)/12.0)
-    prob = 2*(1.0 - azprob(abs(z)))
-    return z, prob
-
-
- def awilcoxont(x,y):
-    """
-Calculates the Wilcoxon T-test for related samples and returns the
-result.  A non-parametric T-test.
-
-Usage:   awilcoxont(x,y)     where x,y are equal-length arrays for 2 conditions
-Returns: t-statistic, two-tailed p-value
-"""
-    if len(x) <> len(y):
-        raise ValueError, 'Unequal N in awilcoxont.  Aborting.'
-    d = x-y
-    d = N.compress(N.not_equal(d,0),d) # Keep all non-zero differences
-    count = len(d)
-    absd = abs(d)
-    absranked = arankdata(absd)
-    r_plus = 0.0
-    r_minus = 0.0
-    for i in range(len(absd)):
-        if d[i] < 0:
-            r_minus = r_minus + absranked[i]
-        else:
-            r_plus = r_plus + absranked[i]
-    wt = min(r_plus, r_minus)
-    mn = count * (count+1) * 0.25
-    se =  math.sqrt(count*(count+1)*(2.0*count+1.0)/24.0)
-    z = math.fabs(wt-mn) / se
-    z = math.fabs(wt-mn) / se
-    prob = 2*(1.0 -zprob(abs(z)))
-    return wt, prob
-
-
- def akruskalwallish(*args):
-    """
-The Kruskal-Wallis H-test is a non-parametric ANOVA for 3 or more
-groups, requiring at least 5 subjects in each group.  This function
-calculates the Kruskal-Wallis H and associated p-value for 3 or more
-independent samples.
-
-Usage:   akruskalwallish(*args)     args are separate arrays for 3+ conditions
-Returns: H-statistic (corrected for ties), associated p-value
-"""
-    assert len(args) == 3, "Need at least 3 groups in stats.akruskalwallish()"
-    args = list(args)
-    n = [0]*len(args)
-    n = map(len,args)
-    all = []
-    for i in range(len(args)):
-        all = all + args[i].tolist()
-    ranked = rankdata(all)
-    T = tiecorrect(ranked)
-    for i in range(len(args)):
-        args[i] = ranked[0:n[i]]
-        del ranked[0:n[i]]
-    rsums = []
-    for i in range(len(args)):
-        rsums.append(sum(args[i])**2)
-        rsums[i] = rsums[i] / float(n[i])
-    ssbn = sum(rsums)
-    totaln = sum(n)
-    h = 12.0 / (totaln*(totaln+1)) * ssbn - 3*(totaln+1)
-    df = len(args) - 1
-    if T == 0:
-        raise ValueError, 'All numbers are identical in akruskalwallish'
-    h = h / float(T)
-    return h, chisqprob(h,df)
-
-
- def afriedmanchisquare(*args):
-    """
-Friedman Chi-Square is a non-parametric, one-way within-subjects
-ANOVA.  This function calculates the Friedman Chi-square test for
-repeated measures and returns the result, along with the associated
-probability value.  It assumes 3 or more repeated measures.  Only 3
-levels requires a minimum of 10 subjects in the study.  Four levels
-requires 5 subjects per level(??).
-
-Usage:   afriedmanchisquare(*args)   args are separate arrays for 2+ conditions
-Returns: chi-square statistic, associated p-value
-"""
-    k = len(args)
-    if k < 3:
-        raise ValueError, '\nLess than 3 levels.  Friedman test not appropriate.\n'
-    n = len(args[0])
-    data = apply(pstat.aabut,args)
-    data = data.astype(N.float_)
-    for i in range(len(data)):
-        data[i] = arankdata(data[i])
-    ssbn = asum(asum(args,1)**2)
-    chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)
-    return chisq, achisqprob(chisq,k-1)
-
-
-#####################################
-####  APROBABILITY CALCULATIONS  ####
-#####################################
-
- def achisqprob(chisq,df):
-    """
-Returns the (1-tail) probability value associated with the provided chi-square
-value and df.  Heavily modified from chisq.c in Gary Perlman's |Stat.  Can
-handle multiple dimensions.
-
-Usage:   achisqprob(chisq,df)    chisq=chisquare stat., df=degrees of freedom
-"""
-    BIG = 200.0
-    def ex(x):
-        BIG = 200.0
-        exponents = N.where(N.less(x,-BIG),-BIG,x)
-        return N.exp(exponents)
-
-    if type(chisq) == N.ndarray:
-        arrayflag = 1
-    else:
-        arrayflag = 0
-        chisq = N.array([chisq])
-    if df < 1:
-        return N.ones(chisq.shape,N.float)
-    probs = N.zeros(chisq.shape,N.float_)
-    probs = N.where(N.less_equal(chisq,0),1.0,probs)  # set prob=1 for chisq<0
-    a = 0.5 * chisq
-    if df > 1:
-        y = ex(-a)
-    if df%2 == 0:
-        even = 1
-        s = y*1
-        s2 = s*1
-    else:
-        even = 0
-        s = 2.0 * azprob(-N.sqrt(chisq))
-        s2 = s*1
-    if (df > 2):
-        chisq = 0.5 * (df - 1.0)
-        if even:
-            z = N.ones(probs.shape,N.float_)
-        else:
-            z = 0.5 *N.ones(probs.shape,N.float_)
-        if even:
-            e = N.zeros(probs.shape,N.float_)
-        else:
-            e = N.log(N.sqrt(N.pi)) *N.ones(probs.shape,N.float_)
-        c = N.log(a)
-        mask = N.zeros(probs.shape)
-        a_big = N.greater(a,BIG)
-        a_big_frozen = -1 *N.ones(probs.shape,N.float_)
-        totalelements = N.multiply.reduce(N.array(probs.shape))
-        while asum(mask)<>totalelements:
-            e = N.log(z) + e
-            s = s + ex(c*z-a-e)
-            z = z + 1.0
-#            print z, e, s
-            newmask = N.greater(z,chisq)
-            a_big_frozen = N.where(newmask*N.equal(mask,0)*a_big, s, a_big_frozen)
-            mask = N.clip(newmask+mask,0,1)
-        if even:
-            z = N.ones(probs.shape,N.float_)
-            e = N.ones(probs.shape,N.float_)
-        else:
-            z = 0.5 *N.ones(probs.shape,N.float_)
-            e = 1.0 / N.sqrt(N.pi) / N.sqrt(a) * N.ones(probs.shape,N.float_)
-        c = 0.0
-        mask = N.zeros(probs.shape)
-        a_notbig_frozen = -1 *N.ones(probs.shape,N.float_)
-        while asum(mask)<>totalelements:
-            e = e * (a/z.astype(N.float_))
-            c = c + e
-            z = z + 1.0
-#            print '#2', z, e, c, s, c*y+s2
-            newmask = N.greater(z,chisq)
-            a_notbig_frozen = N.where(newmask*N.equal(mask,0)*(1-a_big),
-                                      c*y+s2, a_notbig_frozen)
-            mask = N.clip(newmask+mask,0,1)
-        probs = N.where(N.equal(probs,1),1,
-                        N.where(N.greater(a,BIG),a_big_frozen,a_notbig_frozen))
-        return probs
-    else:
-        return s
-
-
- def aerfcc(x):
-    """
-Returns the complementary error function erfc(x) with fractional error
-everywhere less than 1.2e-7.  Adapted from Numerical Recipies.  Can
-handle multiple dimensions.
-
-Usage:   aerfcc(x)
-"""
-    z = abs(x)
-    t = 1.0 / (1.0+0.5*z)
-    ans = t * N.exp(-z*z-1.26551223 + t*(1.00002368+t*(0.37409196+t*(0.09678418+t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+t*(-0.82215223+t*0.17087277)))))))))
-    return N.where(N.greater_equal(x,0), ans, 2.0-ans)
-
-
- def azprob(z):
-    """
-Returns the area under the normal curve 'to the left of' the given z value.
-Thus,
-    for z<0, zprob(z) = 1-tail probability
-    for z>0, 1.0-zprob(z) = 1-tail probability
-    for any z, 2.0*(1.0-zprob(abs(z))) = 2-tail probability
-Adapted from z.c in Gary Perlman's |Stat.  Can handle multiple dimensions.
-
-Usage:   azprob(z)    where z is a z-value
-"""
-    def yfunc(y):
-        x = (((((((((((((-0.000045255659 * y
-                         +0.000152529290) * y -0.000019538132) * y
-                       -0.000676904986) * y +0.001390604284) * y
-                     -0.000794620820) * y -0.002034254874) * y
-                   +0.006549791214) * y -0.010557625006) * y
-                 +0.011630447319) * y -0.009279453341) * y
-               +0.005353579108) * y -0.002141268741) * y
-             +0.000535310849) * y +0.999936657524
-        return x
-
-    def wfunc(w):
-        x = ((((((((0.000124818987 * w
-                    -0.001075204047) * w +0.005198775019) * w
-                  -0.019198292004) * w +0.059054035642) * w
-                -0.151968751364) * w +0.319152932694) * w
-              -0.531923007300) * w +0.797884560593) * N.sqrt(w) * 2.0
-        return x
-
-    Z_MAX = 6.0    # maximum meaningful z-value
-    x = N.zeros(z.shape,N.float_) # initialize
-    y = 0.5 * N.fabs(z)
-    x = N.where(N.less(y,1.0),wfunc(y*y),yfunc(y-2.0)) # get x's
-    x = N.where(N.greater(y,Z_MAX*0.5),1.0,x)          # kill those with big Z
-    prob = N.where(N.greater(z,0),(x+1)*0.5,(1-x)*0.5)
-    return prob
-
-
- def aksprob(alam):
-     """
-Returns the probability value for a K-S statistic computed via ks_2samp.
-Adapted from Numerical Recipies.  Can handle multiple dimensions.
-
-Usage:   aksprob(alam)
-"""
-     if type(alam) == N.ndarray:
-         frozen = -1 *N.ones(alam.shape,N.float64)
-         alam = alam.astype(N.float64)
-         arrayflag = 1
-     else:
-         frozen = N.array(-1.)
-         alam = N.array(alam,N.float64)
-         arrayflag = 1
-     mask = N.zeros(alam.shape)
-     fac = 2.0 *N.ones(alam.shape,N.float_)
-     sum = N.zeros(alam.shape,N.float_)
-     termbf = N.zeros(alam.shape,N.float_)
-     a2 = N.array(-2.0*alam*alam,N.float64)
-     totalelements = N.multiply.reduce(N.array(mask.shape))
-     for j in range(1,201):
-         if asum(mask) == totalelements:
-             break
-         exponents = (a2*j*j)
-         overflowmask = N.less(exponents,-746)
-         frozen = N.where(overflowmask,0,frozen)
-         mask = mask+overflowmask
-         term = fac*N.exp(exponents)
-         sum = sum + term
-         newmask = N.where(N.less_equal(abs(term),(0.001*termbf)) +
-                           N.less(abs(term),1.0e-8*sum), 1, 0)
-         frozen = N.where(newmask*N.equal(mask,0), sum, frozen)
-         mask = N.clip(mask+newmask,0,1)
-         fac = -fac
-         termbf = abs(term)
-     if arrayflag:
-         return N.where(N.equal(frozen,-1), 1.0, frozen)  # 1.0 if doesn't converge
-     else:
-         return N.where(N.equal(frozen,-1), 1.0, frozen)[0]  # 1.0 if doesn't converge
-
-
- def afprob (dfnum, dfden, F):
-    """
-Returns the 1-tailed significance level (p-value) of an F statistic
-given the degrees of freedom for the numerator (dfR-dfF) and the degrees
-of freedom for the denominator (dfF).  Can handle multiple dims for F.
-
-Usage:   afprob(dfnum, dfden, F)   where usually dfnum=dfbn, dfden=dfwn
-"""
-    if type(F) == N.ndarray:
-        return abetai(0.5*dfden, 0.5*dfnum, dfden/(1.0*dfden+dfnum*F))
-    else:
-        return abetai(0.5*dfden, 0.5*dfnum, dfden/float(dfden+dfnum*F))
-
-
- def abetacf(a,b,x,verbose=1):
-    """
-Evaluates the continued fraction form of the incomplete Beta function,
-betai.  (Adapted from: Numerical Recipies in C.)  Can handle multiple
-dimensions for x.
-
-Usage:   abetacf(a,b,x,verbose=1)
-"""
-    ITMAX = 200
-    EPS = 3.0e-7
-
-    arrayflag = 1
-    if type(x) == N.ndarray:
-        frozen = N.ones(x.shape,N.float_) *-1  #start out w/ -1s, should replace all
-    else:
-        arrayflag = 0
-        frozen = N.array([-1])
-        x = N.array([x])
-    mask = N.zeros(x.shape)
-    bm = az = am = 1.0
-    qab = a+b
-    qap = a+1.0
-    qam = a-1.0
-    bz = 1.0-qab*x/qap
-    for i in range(ITMAX+1):
-        if N.sum(N.ravel(N.equal(frozen,-1)))==0:
-            break
-        em = float(i+1)
-        tem = em + em
-        d = em*(b-em)*x/((qam+tem)*(a+tem))
-        ap = az + d*am
-        bp = bz+d*bm
-        d = -(a+em)*(qab+em)*x/((qap+tem)*(a+tem))
-        app = ap+d*az
-        bpp = bp+d*bz
-        aold = az*1
-        am = ap/bpp
-        bm = bp/bpp
-        az = app/bpp
-        bz = 1.0
-        newmask = N.less(abs(az-aold),EPS*abs(az))
-        frozen = N.where(newmask*N.equal(mask,0), az, frozen)
-        mask = N.clip(mask+newmask,0,1)
-    noconverge = asum(N.equal(frozen,-1))
-    if noconverge <> 0 and verbose:
-        print 'a or b too big, or ITMAX too small in Betacf for ',noconverge,' elements'
-    if arrayflag:
-        return frozen
-    else:
-        return frozen[0]
-
-
- def agammln(xx):
-    """
-Returns the gamma function of xx.
-    Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
-Adapted from: Numerical Recipies in C.  Can handle multiple dims ... but
-probably doesn't normally have to.
-
-Usage:   agammln(xx)
-"""
-    coeff = [76.18009173, -86.50532033, 24.01409822, -1.231739516,
-             0.120858003e-2, -0.536382e-5]
-    x = xx - 1.0
-    tmp = x + 5.5
-    tmp = tmp - (x+0.5)*N.log(tmp)
-    ser = 1.0
-    for j in range(len(coeff)):
-        x = x + 1
-        ser = ser + coeff[j]/x
-    return -tmp + N.log(2.50662827465*ser)
-
-
- def abetai(a,b,x,verbose=1):
-    """
-Returns the incomplete beta function:
-
-    I-sub-x(a,b) = 1/B(a,b)*(Integral(0,x) of t^(a-1)(1-t)^(b-1) dt)
-
-where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
-function of a.  The continued fraction formulation is implemented
-here, using the betacf function.  (Adapted from: Numerical Recipies in
-C.)  Can handle multiple dimensions.
-
-Usage:   abetai(a,b,x,verbose=1)
-"""
-    TINY = 1e-15
-    if type(a) == N.ndarray:
-        if asum(N.less(x,0)+N.greater(x,1)) <> 0:
-            raise ValueError, 'Bad x in abetai'
-    x = N.where(N.equal(x,0),TINY,x)
-    x = N.where(N.equal(x,1.0),1-TINY,x)
-
-    bt = N.where(N.equal(x,0)+N.equal(x,1), 0, -1)
-    exponents = ( gammln(a+b)-gammln(a)-gammln(b)+a*N.log(x)+b*
-                  N.log(1.0-x) )
-    # 746 (below) is the MAX POSSIBLE BEFORE OVERFLOW
-    exponents = N.where(N.less(exponents,-740),-740,exponents)
-    bt = N.exp(exponents)
-    if type(x) == N.ndarray:
-        ans = N.where(N.less(x,(a+1)/(a+b+2.0)),
-                      bt*abetacf(a,b,x,verbose)/float(a),
-                      1.0-bt*abetacf(b,a,1.0-x,verbose)/float(b))
-    else:
-        if x<(a+1)/(a+b+2.0):
-            ans = bt*abetacf(a,b,x,verbose)/float(a)
-        else:
-            ans = 1.0-bt*abetacf(b,a,1.0-x,verbose)/float(b)
-    return ans
-
-
-#####################################
-#######  AANOVA CALCULATIONS  #######
-#####################################
-
- import numpy.linalg, operator
- LA = numpy.linalg
-
- def aglm(data,para):
-    """
-Calculates a linear model fit ... anova/ancova/lin-regress/t-test/etc. Taken
-from:
-    Peterson et al. Statistical limitations in functional neuroimaging
-    I. Non-inferential methods and statistical models.  Phil Trans Royal Soc
-    Lond B 354: 1239-1260.
-
-Usage:   aglm(data,para)
-Returns: statistic, p-value ???
-"""
-    if len(para) <> len(data):
-        print "data and para must be same length in aglm"
-        return
-    n = len(para)
-    p = pstat.aunique(para)
-    x = N.zeros((n,len(p)))  # design matrix
-    for l in range(len(p)):
-        x[:,l] = N.equal(para,p[l])
-    b = N.dot(N.dot(LA.inv(N.dot(N.transpose(x),x)),  # i.e., b=inv(X'X)X'Y
-                    N.transpose(x)),
-              data)
-    diffs = (data - N.dot(x,b))
-    s_sq = 1./(n-len(p)) * N.dot(N.transpose(diffs), diffs)
-
-    if len(p) == 2:  # ttest_ind
-        c = N.array([1,-1])
-        df = n-2
-        fact = asum(1.0/asum(x,0))  # i.e., 1/n1 + 1/n2 + 1/n3 ...
-        t = N.dot(c,b) / N.sqrt(s_sq*fact)
-        probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
-        return t, probs
-
-
- def aF_oneway(*args):
-    """
-Performs a 1-way ANOVA, returning an F-value and probability given
-any number of groups.  From Heiman, pp.394-7.
-
-Usage:   aF_oneway (*args)    where *args is 2 or more arrays, one per
-                                  treatment group
-Returns: f-value, probability
-"""
-    na = len(args)            # ANOVA on 'na' groups, each in it's own array
-    means = [0]*na
-    vars = [0]*na
-    ns = [0]*na
-    alldata = []
-    tmp = map(N.array,args)
-    means = map(amean,tmp)
-    vars = map(avar,tmp)
-    ns = map(len,args)
-    alldata = N.concatenate(args)
-    bign = len(alldata)
-    sstot = ass(alldata)-(asquare_of_sums(alldata)/float(bign))
-    ssbn = 0
-    for a in args:
-        ssbn = ssbn + asquare_of_sums(N.array(a))/float(len(a))
-    ssbn = ssbn - (asquare_of_sums(alldata)/float(bign))
-    sswn = sstot-ssbn
-    dfbn = na-1
-    dfwn = bign - na
-    msb = ssbn/float(dfbn)
-    msw = sswn/float(dfwn)
-    f = msb/msw
-    prob = fprob(dfbn,dfwn,f)
-    return f, prob
-
-
- def aF_value (ER,EF,dfR,dfF):
-    """
-Returns an F-statistic given the following:
-        ER  = error associated with the null hypothesis (the Restricted model)
-        EF  = error associated with the alternate hypothesis (the Full model)
-        dfR = degrees of freedom the Restricted model
-        dfF = degrees of freedom associated with the Restricted model
-"""
-    return ((ER-EF)/float(dfR-dfF) / (EF/float(dfF)))
-
-
- def outputfstats(Enum, Eden, dfnum, dfden, f, prob):
-     Enum = round(Enum,3)
-     Eden = round(Eden,3)
-     dfnum = round(Enum,3)
-     dfden = round(dfden,3)
-     f = round(f,3)
-     prob = round(prob,3)
-     suffix = ''                       # for *s after the p-value
-     if  prob < 0.001:  suffix = '  ***'
-     elif prob < 0.01:  suffix = '  **'
-     elif prob < 0.05:  suffix = '  *'
-     title = [['EF/ER','DF','Mean Square','F-value','prob','']]
-     lofl = title+[[Enum, dfnum, round(Enum/float(dfnum),3), f, prob, suffix],
-                   [Eden, dfden, round(Eden/float(dfden),3),'','','']]
-     pstat.printcc(lofl)
-     return
-
-
- def F_value_multivariate(ER, EF, dfnum, dfden):
-     """
-Returns an F-statistic given the following:
-        ER  = error associated with the null hypothesis (the Restricted model)
-        EF  = error associated with the alternate hypothesis (the Full model)
-        dfR = degrees of freedom the Restricted model
-        dfF = degrees of freedom associated with the Restricted model
-where ER and EF are matrices from a multivariate F calculation.
-"""
-     if type(ER) in [IntType, FloatType]:
-         ER = N.array([[ER]])
-     if type(EF) in [IntType, FloatType]:
-         EF = N.array([[EF]])
-     n_um = (LA.det(ER) - LA.det(EF)) / float(dfnum)
-     d_en = LA.det(EF) / float(dfden)
-     return n_um / d_en
-
-
-#####################################
-#######  ASUPPORT FUNCTIONS  ########
-#####################################
-
- def asign(a):
-    """
-Usage:   asign(a)
-Returns: array shape of a, with -1 where a<0 and +1 where a>=0
-"""
-    a = N.asarray(a)
-    if ((type(a) == type(1.4)) or (type(a) == type(1))):
-        return a-a-N.less(a,0)+N.greater(a,0)
-    else:
-        return N.zeros(N.shape(a))-N.less(a,0)+N.greater(a,0)
-
-
- def asum (a, dimension=None,keepdims=0):
-     """
-An alternative to the Numeric.add.reduce function, which allows one to
-(1) collapse over multiple dimensions at once, and/or (2) to retain
-all dimensions in the original array (squashing one down to size.
-Dimension can equal None (ravel array first), an integer (the
-dimension over which to operate), or a sequence (operate over multiple
-dimensions).  If keepdims=1, the resulting array will have as many
-dimensions as the input array.
-
-Usage:   asum(a, dimension=None, keepdims=0)
-Returns: array summed along 'dimension'(s), same _number_ of dims if keepdims=1
-"""
-     if type(a) == N.ndarray and a.dtype in [N.int_, N.short, N.ubyte]:
-         a = a.astype(N.float_)
-     if dimension == None:
-         s = N.sum(N.ravel(a))
-     elif type(dimension) in [IntType,FloatType]:
-         s = N.add.reduce(a, dimension)
-         if keepdims == 1:
-             shp = list(a.shape)
-             shp[dimension] = 1
-             s = N.reshape(s,shp)
-     else: # must be a SEQUENCE of dims to sum over
-        dims = list(dimension)
-        dims.sort()
-        dims.reverse()
-        s = a *1.0
-        for dim in dims:
-            s = N.add.reduce(s,dim)
-        if keepdims == 1:
-            shp = list(a.shape)
-            for dim in dims:
-                shp[dim] = 1
-            s = N.reshape(s,shp)
-     return s
-
-
- def acumsum (a,dimension=None):
-    """
-Returns an array consisting of the cumulative sum of the items in the
-passed array.  Dimension can equal None (ravel array first), an
-integer (the dimension over which to operate), or a sequence (operate
-over multiple dimensions, but this last one just barely makes sense).
-
-Usage:   acumsum(a,dimension=None)
-"""
-    if dimension == None:
-        a = N.ravel(a)
-        dimension = 0
-    if type(dimension) in [ListType, TupleType, N.ndarray]:
-        dimension = list(dimension)
-        dimension.sort()
-        dimension.reverse()
-        for d in dimension:
-            a = N.add.accumulate(a,d)
-        return a
-    else:
-        return N.add.accumulate(a,dimension)
-
-
- def ass(inarray, dimension=None, keepdims=0):
-    """
-Squares each value in the passed array, adds these squares & returns
-the result.  Unfortunate function name. :-) Defaults to ALL values in
-the array.  Dimension can equal None (ravel array first), an integer
-(the dimension over which to operate), or a sequence (operate over
-multiple dimensions).  Set keepdims=1 to maintain the original number
-of dimensions.
-
-Usage:   ass(inarray, dimension=None, keepdims=0)
-Returns: sum-along-'dimension' for (inarray*inarray)
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    return asum(inarray*inarray,dimension,keepdims)
-
-
- def asummult (array1,array2,dimension=None,keepdims=0):
-    """
-Multiplies elements in array1 and array2, element by element, and
-returns the sum (along 'dimension') of all resulting multiplications.
-Dimension can equal None (ravel array first), an integer (the
-dimension over which to operate), or a sequence (operate over multiple
-dimensions).  A trivial function, but included for completeness.
-
-Usage:   asummult(array1,array2,dimension=None,keepdims=0)
-"""
-    if dimension == None:
-        array1 = N.ravel(array1)
-        array2 = N.ravel(array2)
-        dimension = 0
-    return asum(array1*array2,dimension,keepdims)
-
-
- def asquare_of_sums(inarray, dimension=None, keepdims=0):
-    """
-Adds the values in the passed array, squares that sum, and returns the
-result.  Dimension can equal None (ravel array first), an integer (the
-dimension over which to operate), or a sequence (operate over multiple
-dimensions).  If keepdims=1, the returned array will have the same
-NUMBER of dimensions as the original.
-
-Usage:   asquare_of_sums(inarray, dimension=None, keepdims=0)
-Returns: the square of the sum over dim(s) in dimension
-"""
-    if dimension == None:
-        inarray = N.ravel(inarray)
-        dimension = 0
-    s = asum(inarray,dimension,keepdims)
-    if type(s) == N.ndarray:
-        return s.astype(N.float_)*s
-    else:
-        return float(s)*s
-
-
- def asumdiffsquared(a,b, dimension=None, keepdims=0):
-    """
-Takes pairwise differences of the values in arrays a and b, squares
-these differences, and returns the sum of these squares.  Dimension
-can equal None (ravel array first), an integer (the dimension over
-which to operate), or a sequence (operate over multiple dimensions).
-keepdims=1 means the return shape = len(a.shape) = len(b.shape)
-
-Usage:   asumdiffsquared(a,b)
-Returns: sum[ravel(a-b)**2]
-"""
-    if dimension == None:
-        inarray = N.ravel(a)
-        dimension = 0
-    return asum((a-b)**2,dimension,keepdims)
-
-
- def ashellsort(inarray):
-    """
-Shellsort algorithm.  Sorts a 1D-array.
-
-Usage:   ashellsort(inarray)
-Returns: sorted-inarray, sorting-index-vector (for original array)
-"""
-    n = len(inarray)
-    svec = inarray *1.0
-    ivec = range(n)
-    gap = n/2   # integer division needed
-    while gap >0:
-        for i in range(gap,n):
-            for j in range(i-gap,-1,-gap):
-                while j>=0 and svec[j]>svec[j+gap]:
-                    temp        = svec[j]
-                    svec[j]     = svec[j+gap]
-                    svec[j+gap] = temp
-                    itemp       = ivec[j]
-                    ivec[j]     = ivec[j+gap]
-                    ivec[j+gap] = itemp
-        gap = gap / 2  # integer division needed
-#    svec is now sorted input vector, ivec has the order svec[i] = vec[ivec[i]]
-    return svec, ivec
-
-
- def arankdata(inarray):
-    """
-Ranks the data in inarray, dealing with ties appropritely.  Assumes
-a 1D inarray.  Adapted from Gary Perlman's |Stat ranksort.
-
-Usage:   arankdata(inarray)
-Returns: array of length equal to inarray, containing rank scores
-"""
-    n = len(inarray)
-    svec, ivec = ashellsort(inarray)
-    sumranks = 0
-    dupcount = 0
-    newarray = N.zeros(n,N.float_)
-    for i in range(n):
-        sumranks = sumranks + i
-        dupcount = dupcount + 1
-        if i==n-1 or svec[i] <> svec[i+1]:
-            averank = sumranks / float(dupcount) + 1
-            for j in range(i-dupcount+1,i+1):
-                newarray[ivec[j]] = averank
-            sumranks = 0
-            dupcount = 0
-    return newarray
-
-
- def afindwithin(data):
-    """
-Returns a binary vector, 1=within-subject factor, 0=between.  Input
-equals the entire data array (i.e., column 1=random factor, last
-column = measured values.
-
-Usage:   afindwithin(data)     data in |Stat format
-"""
-    numfact = len(data[0])-2
-    withinvec = [0]*numfact
-    for col in range(1,numfact+1):
-        rows = pstat.linexand(data,col,pstat.unique(pstat.colex(data,1))[0])  # get 1 level of this factor
-        if len(pstat.unique(pstat.colex(rows,0))) < len(rows):   # if fewer subjects than scores on this factor
-            withinvec[col-1] = 1
-    return withinvec
-
-
- #########################################################
- #########################################################
- ######  RE-DEFINE DISPATCHES TO INCLUDE ARRAYS  #########
- #########################################################
- #########################################################
-
-## CENTRAL TENDENCY:
- geometricmean = Dispatch ( (lgeometricmean, (ListType, TupleType)),
-                            (ageometricmean, (N.ndarray,)) )
- harmonicmean = Dispatch ( (lharmonicmean, (ListType, TupleType)),
-                           (aharmonicmean, (N.ndarray,)) )
- mean = Dispatch ( (lmean, (ListType, TupleType)),
-                   (amean, (N.ndarray,)) )
- median = Dispatch ( (lmedian, (ListType, TupleType)),
-                     (amedian, (N.ndarray,)) )
- medianscore = Dispatch ( (lmedianscore, (ListType, TupleType)),
-                          (amedianscore, (N.ndarray,)) )
- mode = Dispatch ( (lmode, (ListType, TupleType)),
-                   (amode, (N.ndarray,)) )
- tmean = Dispatch ( (atmean, (N.ndarray,)) )
- tvar = Dispatch ( (atvar, (N.ndarray,)) )
- tstdev = Dispatch ( (atstdev, (N.ndarray,)) )
- tsem = Dispatch ( (atsem, (N.ndarray,)) )
-
-## VARIATION:
- moment = Dispatch ( (lmoment, (ListType, TupleType)),
-                     (amoment, (N.ndarray,)) )
- variation = Dispatch ( (lvariation, (ListType, TupleType)),
-                        (avariation, (N.ndarray,)) )
- skew = Dispatch ( (lskew, (ListType, TupleType)),
-                   (askew, (N.ndarray,)) )
- kurtosis = Dispatch ( (lkurtosis, (ListType, TupleType)),
-                       (akurtosis, (N.ndarray,)) )
- describe = Dispatch ( (ldescribe, (ListType, TupleType)),
-                       (adescribe, (N.ndarray,)) )
-
-## DISTRIBUTION TESTS
-
- skewtest = Dispatch ( (askewtest, (ListType, TupleType)),
-                       (askewtest, (N.ndarray,)) )
- kurtosistest = Dispatch ( (akurtosistest, (ListType, TupleType)),
-                           (akurtosistest, (N.ndarray,)) )
- normaltest = Dispatch ( (anormaltest, (ListType, TupleType)),
-                         (anormaltest, (N.ndarray,)) )
-
-## FREQUENCY STATS:
- itemfreq = Dispatch ( (litemfreq, (ListType, TupleType)),
-                       (aitemfreq, (N.ndarray,)) )
- scoreatpercentile = Dispatch ( (lscoreatpercentile, (ListType, TupleType)),
-                                (ascoreatpercentile, (N.ndarray,)) )
- percentileofscore = Dispatch ( (lpercentileofscore, (ListType, TupleType)),
-                                 (apercentileofscore, (N.ndarray,)) )
- histogram = Dispatch ( (lhistogram, (ListType, TupleType)),
-                        (ahistogram, (N.ndarray,)) )
- cumfreq = Dispatch ( (lcumfreq, (ListType, TupleType)),
-                      (acumfreq, (N.ndarray,)) )
- relfreq = Dispatch ( (lrelfreq, (ListType, TupleType)),
-                      (arelfreq, (N.ndarray,)) )
-
-## VARIABILITY:
- obrientransform = Dispatch ( (lobrientransform, (ListType, TupleType)),
-                              (aobrientransform, (N.ndarray,)) )
- samplevar = Dispatch ( (lsamplevar, (ListType, TupleType)),
-                        (asamplevar, (N.ndarray,)) )
- samplestdev = Dispatch ( (lsamplestdev, (ListType, TupleType)),
-                          (asamplestdev, (N.ndarray,)) )
- signaltonoise = Dispatch( (asignaltonoise, (N.ndarray,)),)
- var = Dispatch ( (lvar, (ListType, TupleType)),
-                  (avar, (N.ndarray,)) )
- stdev = Dispatch ( (lstdev, (ListType, TupleType)),
-                    (astdev, (N.ndarray,)) )
- sterr = Dispatch ( (lsterr, (ListType, TupleType)),
-                    (asterr, (N.ndarray,)) )
- sem = Dispatch ( (lsem, (ListType, TupleType)),
-                  (asem, (N.ndarray,)) )
- z = Dispatch ( (lz, (ListType, TupleType)),
-                (az, (N.ndarray,)) )
- zs = Dispatch ( (lzs, (ListType, TupleType)),
-                 (azs, (N.ndarray,)) )
-
-## TRIMMING FCNS:
- threshold = Dispatch( (athreshold, (N.ndarray,)),)
- trimboth = Dispatch ( (ltrimboth, (ListType, TupleType)),
-                       (atrimboth, (N.ndarray,)) )
- trim1 = Dispatch ( (ltrim1, (ListType, TupleType)),
-                    (atrim1, (N.ndarray,)) )
-
-## CORRELATION FCNS:
- paired = Dispatch ( (lpaired, (ListType, TupleType)),
-                     (apaired, (N.ndarray,)) )
- lincc = Dispatch ( (llincc, (ListType, TupleType)),
-                       (alincc, (N.ndarray,)) )
- pearsonr = Dispatch ( (lpearsonr, (ListType, TupleType)),
-                       (apearsonr, (N.ndarray,)) )
- spearmanr = Dispatch ( (lspearmanr, (ListType, TupleType)),
-                        (aspearmanr, (N.ndarray,)) )
- pointbiserialr = Dispatch ( (lpointbiserialr, (ListType, TupleType)),
-                             (apointbiserialr, (N.ndarray,)) )
- kendalltau = Dispatch ( (lkendalltau, (ListType, TupleType)),
-                         (akendalltau, (N.ndarray,)) )
- linregress = Dispatch ( (llinregress, (ListType, TupleType)),
-                         (alinregress, (N.ndarray,)) )
-
-## INFERENTIAL STATS:
- ttest_1samp = Dispatch ( (lttest_1samp, (ListType, TupleType)),
-                          (attest_1samp, (N.ndarray,)) )
- ttest_ind = Dispatch ( (lttest_ind, (ListType, TupleType)),
-                        (attest_ind, (N.ndarray,)) )
- ttest_rel = Dispatch ( (lttest_rel, (ListType, TupleType)),
-                        (attest_rel, (N.ndarray,)) )
- chisquare = Dispatch ( (lchisquare, (ListType, TupleType)),
-                        (achisquare, (N.ndarray,)) )
- ks_2samp = Dispatch ( (lks_2samp, (ListType, TupleType)),
-                       (aks_2samp, (N.ndarray,)) )
- mannwhitneyu = Dispatch ( (lmannwhitneyu, (ListType, TupleType)),
-                           (amannwhitneyu, (N.ndarray,)) )
- tiecorrect = Dispatch ( (ltiecorrect, (ListType, TupleType)),
-                         (atiecorrect, (N.ndarray,)) )
- ranksums = Dispatch ( (lranksums, (ListType, TupleType)),
-                       (aranksums, (N.ndarray,)) )
- wilcoxont = Dispatch ( (lwilcoxont, (ListType, TupleType)),
-                        (awilcoxont, (N.ndarray,)) )
- kruskalwallish = Dispatch ( (lkruskalwallish, (ListType, TupleType)),
-                             (akruskalwallish, (N.ndarray,)) )
- friedmanchisquare = Dispatch ( (lfriedmanchisquare, (ListType, TupleType)),
-                                (afriedmanchisquare, (N.ndarray,)) )
-
-## PROBABILITY CALCS:
- chisqprob = Dispatch ( (lchisqprob, (IntType, FloatType)),
-                        (achisqprob, (N.ndarray,)) )
- zprob = Dispatch ( (lzprob, (IntType, FloatType)),
-                    (azprob, (N.ndarray,)) )
- ksprob = Dispatch ( (lksprob, (IntType, FloatType)),
-                     (aksprob, (N.ndarray,)) )
- fprob = Dispatch ( (lfprob, (IntType, FloatType)),
-                    (afprob, (N.ndarray,)) )
- betacf = Dispatch ( (lbetacf, (IntType, FloatType)),
-                     (abetacf, (N.ndarray,)) )
- betai = Dispatch ( (lbetai, (IntType, FloatType)),
-                    (abetai, (N.ndarray,)) )
- erfcc = Dispatch ( (lerfcc, (IntType, FloatType)),
-                    (aerfcc, (N.ndarray,)) )
- gammln = Dispatch ( (lgammln, (IntType, FloatType)),
-                     (agammln, (N.ndarray,)) )
-
-## ANOVA FUNCTIONS:
- F_oneway = Dispatch ( (lF_oneway, (ListType, TupleType)),
-                       (aF_oneway, (N.ndarray,)) )
- F_value = Dispatch ( (lF_value, (ListType, TupleType)),
-                      (aF_value, (N.ndarray,)) )
-
-## SUPPORT FUNCTIONS:
- incr = Dispatch ( (lincr, (ListType, TupleType, N.ndarray)), )
- sum = Dispatch ( (lsum, (ListType, TupleType)),
-                  (asum, (N.ndarray,)) )
- cumsum = Dispatch ( (lcumsum, (ListType, TupleType)),
-                     (acumsum, (N.ndarray,)) )
- ss = Dispatch ( (lss, (ListType, TupleType)),
-                 (ass, (N.ndarray,)) )
- summult = Dispatch ( (lsummult, (ListType, TupleType)),
-                      (asummult, (N.ndarray,)) )
- square_of_sums = Dispatch ( (lsquare_of_sums, (ListType, TupleType)),
-                             (asquare_of_sums, (N.ndarray,)) )
- sumdiffsquared = Dispatch ( (lsumdiffsquared, (ListType, TupleType)),
-                             (asumdiffsquared, (N.ndarray,)) )
- shellsort = Dispatch ( (lshellsort, (ListType, TupleType)),
-                        (ashellsort, (N.ndarray,)) )
- rankdata = Dispatch ( (lrankdata, (ListType, TupleType)),
-                       (arankdata, (N.ndarray,)) )
- findwithin = Dispatch ( (lfindwithin, (ListType, TupleType)),
-                         (afindwithin, (N.ndarray,)) )
-
-######################  END OF NUMERIC FUNCTION BLOCK  #####################
-
-######################  END OF STATISTICAL FUNCTIONS  ######################
-
-except ImportError:
- pass
diff --git a/v14/utils/tabulator.py b/v14/utils/tabulator.py
deleted file mode 100644
index f75419ab..00000000
--- a/v14/utils/tabulator.py
+++ /dev/null
@@ -1,1125 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-
-"""Table generating, analyzing and printing functions.
-
-This defines several classes that are used to generate, analyze and print
-tables.
-
-Example usage:
-
-  from utils import tabulator
-
-  data = [["benchmark1", "33", "44"],["benchmark2", "44", "33"]]
-  tabulator.GetSimpleTable(data)
-
-You could also use it to generate more complex tables with analysis such as
-p-values, custom colors, etc. Tables are generated by TableGenerator and
-analyzed/formatted by TableFormatter. TableFormatter can take in a list of
-columns with custom result computation and coloring, and will compare values in
-each row according to taht scheme. Here is a complex example on printing a
-table:
-
-  from utils import tabulator
-
-  runs = [[{"k1": "10", "k2": "12", "k5": "40", "k6": "40",
-            "ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
-            "k10": "0"},
-           {"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
-            "k9": "FAIL", "k10": "0"}],
-          [{"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
-            "45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
-            "PASS"}]]
-  labels = ["vanilla", "modified"]
-  tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
-  table = tg.GetTable()
-  columns = [Column(LiteralResult(),
-                    Format(),
-                    "Literal"),
-             Column(AmeanResult(),
-                    Format()),
-             Column(StdResult(),
-                    Format()),
-             Column(CoeffVarResult(),
-                    CoeffVarFormat()),
-             Column(NonEmptyCountResult(),
-                    Format()),
-             Column(AmeanRatioResult(),
-                    PercentFormat()),
-             Column(AmeanRatioResult(),
-                    RatioFormat()),
-             Column(GmeanRatioResult(),
-                    RatioFormat()),
-             Column(PValueResult(),
-                    PValueFormat()),
-            ]
-  tf = TableFormatter(table, columns)
-  cell_table = tf.GetCellTable()
-  tp = TablePrinter(cell_table, out_to)
-  print tp.Print()
-
-"""
-
-
-import getpass
-import math
-import sys
-import numpy
-
-import colortrans
-from email_sender import EmailSender
-import misc
-
-
-def _AllFloat(values):
-  return all([misc.IsFloat(v) for v in values])
-
-
-def _GetFloats(values):
-  return [float(v) for v in values]
-
-
-def _StripNone(results):
-  res = []
-  for result in results:
-    if result is not None:
-      res.append(result)
-  return res
-
-
-class TableGenerator(object):
-  """Creates a table from a list of list of dicts.
-
-  The main public function is called GetTable().
-  """
-  SORT_BY_KEYS = 0
-  SORT_BY_KEYS_DESC = 1
-  SORT_BY_VALUES = 2
-  SORT_BY_VALUES_DESC = 3
-
-  MISSING_VALUE = "x"
-
-  def __init__(self, d, l, sort=SORT_BY_KEYS, key_name="keys"):
-    self._runs = d
-    self._labels = l
-    self._sort = sort
-    self._key_name = key_name
-
-  def _AggregateKeys(self):
-    keys = set([])
-    for run_list in self._runs:
-      for run in run_list:
-        keys = keys.union(run.keys())
-    return keys
-
-  def _GetHighestValue(self, key):
-    values = []
-    for run_list in self._runs:
-      for run in run_list:
-        if key in run:
-          values.append(run[key])
-    values = _StripNone(values)
-    if _AllFloat(values):
-      values = _GetFloats(values)
-    return max(values)
-
-  def _GetLowestValue(self, key):
-    values = []
-    for run_list in self._runs:
-      for run in run_list:
-        if key in run:
-          values.append(run[key])
-    values = _StripNone(values)
-    if _AllFloat(values):
-      values = _GetFloats(values)
-    return min(values)
-
-  def _SortKeys(self, keys):
-    if self._sort == self.SORT_BY_KEYS:
-      return sorted(keys)
-    elif self._sort == self.SORT_BY_VALUES:
-      # pylint: disable=unnecessary-lambda
-      return sorted(keys, key=lambda x: self._GetLowestValue(x))
-    elif self._sort == self.SORT_BY_VALUES_DESC:
-      # pylint: disable=unnecessary-lambda
-      return sorted(keys, key=lambda x: self._GetHighestValue(x), reverse=True)
-    else:
-      assert 0, "Unimplemented sort %s" % self._sort
-
-  def _GetKeys(self):
-    keys = self._AggregateKeys()
-    return self._SortKeys(keys)
-
-  def GetTable(self, number_of_rows=sys.maxint):
-    """Returns a table from a list of list of dicts.
-
-    The list of list of dicts is passed into the constructor of TableGenerator.
-    This method converts that into a canonical list of lists which represents a
-    table of values.
-
-    Args:
-      number_of_rows: Maximum number of rows to return from the table.
-    Returns:
-      A list of lists which is the table.
-
-    Example:
-      We have the following runs:
-        [[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}],
-         [{"k1": "v4", "k4": "v5"}]]
-      and the following labels:
-        ["vanilla", "modified"]
-      it will return:
-        [["Key", "vanilla", "modified"]
-         ["k1", ["v1", "v3"], ["v4"]]
-         ["k2", ["v2"], []]
-         ["k4", [], ["v5"]]]
-      The returned table can then be processed further by other classes in this
-      module.
-    """
-    keys = self._GetKeys()
-    header = [self._key_name] + self._labels
-    table = [header]
-    rows = 0
-    for k in keys:
-      row = [k]
-      for run_list in self._runs:
-        v = []
-        for run in run_list:
-          if k in run:
-            v.append(run[k])
-          else:
-            v.append(None)
-        row.append(v)
-      table.append(row)
-      rows += 1
-      if rows == number_of_rows:
-        break
-    return table
-
-
-class Result(object):
-  """A class that respresents a single result.
-
-  This single result is obtained by condensing the information from a list of
-  runs and a list of baseline runs.
-  """
-
-  def __init__(self):
-    pass
-
-  def _AllStringsSame(self, values):
-    values_set = set(values)
-    return len(values_set) == 1
-
-  def NeedsBaseline(self):
-    return False
-
-  # pylint: disable=unused-argument
-  def _Literal(self, cell, values, baseline_values):
-    cell.value = " ".join([str(v) for v in values])
-
-  def _ComputeFloat(self, cell, values, baseline_values):
-    self._Literal(cell, values, baseline_values)
-
-  def _ComputeString(self, cell, values, baseline_values):
-    self._Literal(cell, values, baseline_values)
-
-  def _InvertIfLowerIsBetter(self, cell):
-    pass
-
-  def _GetGmean(self, values):
-    if not values:
-      return float("nan")
-    if any([v < 0 for v in values]):
-      return float ("nan")
-    if any([v == 0 for v in values]):
-      return 0.0
-    log_list = [math.log(v) for v in values]
-    gmean_log = sum(log_list)/len(log_list)
-    return math.exp(gmean_log)
-
-  def Compute(self, cell, values, baseline_values):
-    """Compute the result given a list of values and baseline values.
-
-    Args:
-      cell: A cell data structure to populate.
-      values: List of values.
-      baseline_values: List of baseline values. Can be none if this is the
-      baseline itself.
-    """
-    all_floats = True
-    values = _StripNone(values)
-    if not values:
-      cell.value = ""
-      return
-    if _AllFloat(values):
-      float_values = _GetFloats(values)
-    else:
-      all_floats = False
-    if baseline_values:
-      baseline_values = _StripNone(baseline_values)
-    if baseline_values:
-      if _AllFloat(baseline_values):
-        float_baseline_values = _GetFloats(baseline_values)
-      else:
-        all_floats = False
-    else:
-      if self.NeedsBaseline():
-        cell.value = ""
-        return
-      float_baseline_values = None
-    if all_floats:
-      self._ComputeFloat(cell, float_values, float_baseline_values)
-      self._InvertIfLowerIsBetter(cell)
-    else:
-      self._ComputeString(cell, values, baseline_values)
-
-
-class LiteralResult(Result):
-  def __init__(self, iteration=0):
-    super(LiteralResult, self).__init__()
-    self.iteration = iteration
-
-  def Compute(self, cell, values, baseline_values):
-    try:
-      cell.value = values[self.iteration]
-    except IndexError:
-      cell.value = "-"
-
-
-class NonEmptyCountResult(Result):
-  """A class that counts the number of non-empty results.
-
-  The number of non-empty values will be stored in the cell.
-  """
-
-  def Compute(self, cell, values, baseline_values):
-    """Put the number of non-empty values in the cell result.
-
-    Args:
-      cell: Put the result in cell.value.
-      values: A list of values for the row.
-      baseline_values: A list of baseline values for the row.
-    """
-    cell.value = len(_StripNone(values))
-    if not baseline_values:
-      return
-    base_value = len(_StripNone(baseline_values))
-    if cell.value == base_value:
-      return
-    f = ColorBoxFormat()
-    len_values = len(values)
-    len_baseline_values = len(baseline_values)
-    tmp_cell = Cell()
-    tmp_cell.value = 1.0 + (float(cell.value - base_value) /
-                            (max(len_values, len_baseline_values)))
-    f.Compute(tmp_cell)
-    cell.bgcolor = tmp_cell.bgcolor
-
-
-class StringMeanResult(Result):
-  def _ComputeString(self, cell, values, baseline_values):
-    if self._AllStringsSame(values):
-      cell.value = str(values[0])
-    else:
-      cell.value = "?"
-
-
-class AmeanResult(StringMeanResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    cell.value = numpy.mean(values)
-
-
-class RawResult(Result):
-  pass
-
-
-class MinResult(Result):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    cell.value = min(values)
-
-  def _ComputeString(self, cell, values, baseline_values):
-    if values:
-      cell.value = min(values)
-    else:
-      cell.value = ""
-
-
-class MaxResult(Result):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    cell.value = max(values)
-
-  def _ComputeString(self, cell, values, baseline_values):
-    if values:
-      cell.value = max(values)
-    else:
-      cell.value = ""
-
-
-class NumericalResult(Result):
-  def _ComputeString(self, cell, values, baseline_values):
-    cell.value = "?"
-
-
-class StdResult(NumericalResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    cell.value = numpy.std(values)
-
-
-class CoeffVarResult(NumericalResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    noise = numpy.abs(numpy.std(values)/numpy.mean(values))
-    cell.value = noise
-
-
-class ComparisonResult(Result):
-  def NeedsBaseline(self):
-    return True
-
-  def _ComputeString(self, cell, values, baseline_values):
-    value = None
-    baseline_value = None
-    if self._AllStringsSame(values):
-      value = values[0]
-    if self._AllStringsSame(baseline_values):
-      baseline_value = baseline_values[0]
-    if value is not None and baseline_value is not None:
-      if value == baseline_value:
-        cell.value = "SAME"
-      else:
-        cell.value = "DIFFERENT"
-    else:
-      cell.value = "?"
-
-
-class PValueResult(ComparisonResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    if len(values) < 2 or len(baseline_values) < 2:
-      cell.value = float("nan")
-      return
-    import stats  # pylint: disable=g-import-not-at-top
-    _, cell.value = stats.lttest_ind(values, baseline_values)
-
-  def _ComputeString(self, cell, values, baseline_values):
-    return float("nan")
-
-
-class KeyAwareComparisonResult(ComparisonResult):
-  def _IsLowerBetter(self, key):
-    lower_is_better_keys = ["milliseconds", "ms", "seconds", "KB",
-                            "rdbytes", "wrbytes"]
-    return any([key.startswith(l + "_") for l in lower_is_better_keys])
-
-  def _InvertIfLowerIsBetter(self, cell):
-    if self._IsLowerBetter(cell.name):
-      if cell.value:
-        cell.value = 1.0/cell.value
-
-
-class AmeanRatioResult(KeyAwareComparisonResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    if numpy.mean(baseline_values) != 0:
-      cell.value = numpy.mean(values)/numpy.mean(baseline_values)
-    elif numpy.mean(values) != 0:
-      cell.value = 0.00
-      # cell.value = 0 means the values and baseline_values have big difference
-    else:
-      cell.value = 1.00
-      # no difference if both values and baseline_values are 0
-
-
-class GmeanRatioResult(KeyAwareComparisonResult):
-  def _ComputeFloat(self, cell, values, baseline_values):
-    if self._GetGmean(baseline_values) != 0:
-      cell.value = self._GetGmean(values)/self._GetGmean(baseline_values)
-    elif self._GetGmean(values) != 0:
-      cell.value = 0.00
-    else:
-      cell.value = 1.00
-
-
-class Color(object):
-  """Class that represents color in RGBA format."""
-
-  def __init__(self, r=0, g=0, b=0, a=0):
-    self.r = r
-    self.g = g
-    self.b = b
-    self.a = a
-
-  def __str__(self):
-    return "r: %s g: %s: b: %s: a: %s" % (self.r, self.g, self.b, self.a)
-
-  def Round(self):
-    """Round RGBA values to the nearest integer."""
-    self.r = int(self.r)
-    self.g = int(self.g)
-    self.b = int(self.b)
-    self.a = int(self.a)
-
-  def GetRGB(self):
-    """Get a hex representation of the color."""
-    return "%02x%02x%02x" % (self.r, self.g, self.b)
-
-  @classmethod
-  def Lerp(cls, ratio, a, b):
-    """Perform linear interpolation between two colors.
-
-    Args:
-      ratio: The ratio to use for linear polation.
-      a: The first color object (used when ratio is 0).
-      b: The second color object (used when ratio is 1).
-
-    Returns:
-      Linearly interpolated color.
-    """
-    ret = cls()
-    ret.r = (b.r - a.r)*ratio + a.r
-    ret.g = (b.g - a.g)*ratio + a.g
-    ret.b = (b.b - a.b)*ratio + a.b
-    ret.a = (b.a - a.a)*ratio + a.a
-    return ret
-
-
-class Format(object):
-  """A class that represents the format of a column."""
-
-  def __init__(self):
-    pass
-
-  def Compute(self, cell):
-    """Computes the attributes of a cell based on its value.
-
-    Attributes typically are color, width, etc.
-
-    Args:
-      cell: The cell whose attributes are to be populated.
-    """
-    if cell.value is None:
-      cell.string_value = ""
-    if isinstance(cell.value, float):
-      self._ComputeFloat(cell)
-    else:
-      self._ComputeString(cell)
-
-  def _ComputeFloat(self, cell):
-    cell.string_value = "{0:.2f}".format(cell.value)
-
-  def _ComputeString(self, cell):
-    cell.string_value = str(cell.value)
-
-  def _GetColor(self, value, low, mid, high, power=6, mid_value=1.0):
-    min_value = 0.0
-    max_value = 2.0
-    if math.isnan(value):
-      return mid
-    if value > mid_value:
-      value = max_value - mid_value/value
-
-    return self._GetColorBetweenRange(value, min_value, mid_value, max_value,
-                                      low, mid, high, power)
-
-  def _GetColorBetweenRange(self,
-                            value,
-                            min_value, mid_value, max_value,
-                            low_color, mid_color, high_color,
-                            power):
-    assert value <= max_value
-    assert value >= min_value
-    if value > mid_value:
-      value = (max_value - value)/(max_value - mid_value)
-      value **= power
-      ret = Color.Lerp(value, high_color, mid_color)
-    else:
-      value = (value - min_value)/(mid_value - min_value)
-      value **= power
-      ret = Color.Lerp(value, low_color, mid_color)
-    ret.Round()
-    return ret
-
-
-class PValueFormat(Format):
-  def _ComputeFloat(self, cell):
-    cell.string_value = "%0.2f" % float(cell.value)
-    if float(cell.value) < 0.05:
-      cell.bgcolor = self._GetColor(cell.value,
-                                    Color(255, 255, 0, 0),
-                                    Color(255, 255, 255, 0),
-                                    Color(255, 255, 255, 0),
-                                    mid_value=0.05,
-                                    power=1)
-
-
-class StorageFormat(Format):
-  """Format the cell as a storage number.
-
-  Example:
-    If the cell contains a value of 1024, the string_value will be 1.0K.
-  """
-
-  def _ComputeFloat(self, cell):
-    base = 1024
-    suffices = ["K", "M", "G"]
-    v = float(cell.value)
-    current = 0
-    while v >= base**(current + 1) and current < len(suffices):
-      current += 1
-
-    if current:
-      divisor = base**current
-      cell.string_value = "%1.1f%s" % ((v/divisor), suffices[current - 1])
-    else:
-      cell.string_value = str(cell.value)
-
-
-class CoeffVarFormat(Format):
-  """Format the cell as a percent.
-
-  Example:
-    If the cell contains a value of 1.5, the string_value will be +150%.
-  """
-
-  def _ComputeFloat(self, cell):
-    cell.string_value = "%1.1f%%" % (float(cell.value) * 100)
-    cell.color = self._GetColor(cell.value,
-                                Color(0, 255, 0, 0),
-                                Color(0, 0, 0, 0),
-                                Color(255, 0, 0, 0),
-                                mid_value=0.02,
-                                power=1)
-
-
-class PercentFormat(Format):
-  """Format the cell as a percent.
-
-  Example:
-    If the cell contains a value of 1.5, the string_value will be +50%.
-  """
-
-  def _ComputeFloat(self, cell):
-    cell.string_value = "%+1.1f%%" % ((float(cell.value) - 1) * 100)
-    cell.color = self._GetColor(cell.value,
-                                Color(255, 0, 0, 0),
-                                Color(0, 0, 0, 0),
-                                Color(0, 255, 0, 0))
-
-
-class RatioFormat(Format):
-  """Format the cell as a ratio.
-
-  Example:
-    If the cell contains a value of 1.5642, the string_value will be 1.56.
-  """
-
-  def _ComputeFloat(self, cell):
-    cell.string_value = "%+1.1f%%" % ((cell.value - 1) * 100)
-    cell.color = self._GetColor(cell.value,
-                                Color(255, 0, 0, 0),
-                                Color(0, 0, 0, 0),
-                                Color(0, 255, 0, 0))
-
-
-class ColorBoxFormat(Format):
-  """Format the cell as a color box.
-
-  Example:
-    If the cell contains a value of 1.5, it will get a green color.
-    If the cell contains a value of 0.5, it will get a red color.
-    The intensity of the green/red will be determined by how much above or below
-    1.0 the value is.
-  """
-
-  def _ComputeFloat(self, cell):
-    cell.string_value = "--"
-    bgcolor = self._GetColor(cell.value,
-                             Color(255, 0, 0, 0),
-                             Color(255, 255, 255, 0),
-                             Color(0, 255, 0, 0))
-    cell.bgcolor = bgcolor
-    cell.color = bgcolor
-
-
-class Cell(object):
-  """A class to represent a cell in a table.
-
-  Attributes:
-    value: The raw value of the cell.
-    color: The color of the cell.
-    bgcolor: The background color of the cell.
-    string_value: The string value of the cell.
-    suffix: A string suffix to be attached to the value when displaying.
-    prefix: A string prefix to be attached to the value when displaying.
-    color_row: Indicates whether the whole row is to inherit this cell's color.
-    bgcolor_row: Indicates whether the whole row is to inherit this cell's
-    bgcolor.
-    width: Optional specifier to make a column narrower than the usual width.
-    The usual width of a column is the max of all its cells widths.
-    colspan: Set the colspan of the cell in the HTML table, this is used for
-    table headers. Default value is 1.
-    name: the test name of the cell.
-    header: Whether this is a header in html.
-  """
-
-  def __init__(self):
-    self.value = None
-    self.color = None
-    self.bgcolor = None
-    self.string_value = None
-    self.suffix = None
-    self.prefix = None
-    # Entire row inherits this color.
-    self.color_row = False
-    self.bgcolor_row = False
-    self.width = None
-    self.colspan = 1
-    self.name = None
-    self.header = False
-
-  def __str__(self):
-    l = []
-    l.append("value: %s" % self.value)
-    l.append("string_value: %s" % self.string_value)
-    return " ".join(l)
-
-
-class Column(object):
-  """Class representing a column in a table.
-
-  Attributes:
-    result: an object of the Result class.
-    fmt: an object of the Format class.
-  """
-
-  def __init__(self, result, fmt, name=""):
-    self.result = result
-    self.fmt = fmt
-    self.name = name
-
-
-# Takes in:
-# ["Key", "Label1", "Label2"]
-# ["k", ["v", "v2"], [v3]]
-# etc.
-# Also takes in a format string.
-# Returns a table like:
-# ["Key", "Label1", "Label2"]
-# ["k", avg("v", "v2"), stddev("v", "v2"), etc.]]
-# according to format string
-class TableFormatter(object):
-  """Class to convert a plain table into a cell-table.
-
-  This class takes in a table generated by TableGenerator and a list of column
-  formats to apply to the table and returns a table of cells.
-  """
-
-  def __init__(self, table, columns):
-    """The constructor takes in a table and a list of columns.
-
-    Args:
-      table: A list of lists of values.
-      columns: A list of column containing what to produce and how to format it.
-    """
-    self._table = table
-    self._columns = columns
-    self._table_columns = []
-    self._out_table = []
-
-  def GenerateCellTable(self):
-    row_index = 0
-
-    for row in self._table[1:]:
-      key = Cell()
-      key.string_value = str(row[0])
-      out_row = [key]
-      baseline = None
-      for values in row[1:]:
-        for column in self._columns:
-          cell = Cell()
-          cell.name = key.string_value
-          if column.result.NeedsBaseline():
-            if baseline is not None:
-              column.result.Compute(cell, values, baseline)
-              column.fmt.Compute(cell)
-              out_row.append(cell)
-              if not row_index:
-                self._table_columns.append(column)
-          else:
-            column.result.Compute(cell, values, baseline)
-            column.fmt.Compute(cell)
-            out_row.append(cell)
-            if not row_index:
-              self._table_columns.append(column)
-
-        if baseline is None:
-          baseline = values
-      self._out_table.append(out_row)
-      row_index += 1
-
-  def AddColumnName(self):
-    """Generate Column name at the top of table."""
-    key = Cell()
-    key.header = True
-    key.string_value = "Keys"
-    header = [key]
-    for column in self._table_columns:
-      cell = Cell()
-      cell.header = True
-      if column.name:
-        cell.string_value = column.name
-      else:
-        result_name = column.result.__class__.__name__
-        format_name = column.fmt.__class__.__name__
-
-        cell.string_value = "%s %s" % (result_name.replace("Result", ""),
-                                       format_name.replace("Format", ""))
-
-      header.append(cell)
-
-    self._out_table = [header] + self._out_table
-
-  def AddHeader(self, s):
-    """Put additional string on the top of the table."""
-    cell = Cell()
-    cell.header = True
-    cell.string_value = str(s)
-    header = [cell]
-    colspan = max(1, max(len(row) for row in self._table))
-    cell.colspan = colspan
-    self._out_table = [header] + self._out_table
-
-  def AddLabelName(self):
-    """Put label on the top of the table."""
-    top_header = []
-    base_colspan = len([c for c in self._columns
-                        if not c.result.NeedsBaseline()])
-    compare_colspan = len(self._columns)
-    # The label is organized as follows
-    # "keys" label_base, label_comparison1, label_comparison2
-    # The first cell has colspan 1, the second is base_colspan
-    # The others are compare_colspan
-    for label in self._table[0]:
-      cell = Cell()
-      cell.header = True
-      cell.string_value = str(label)
-      if top_header:
-        cell.colspan = base_colspan
-      if len(top_header) > 1:
-        cell.colspan = compare_colspan
-      top_header.append(cell)
-    self._out_table = [top_header] + self._out_table
-
-  def _PrintOutTable(self):
-    o = ""
-    for row in self._out_table:
-      for cell in row:
-        o += str(cell) + " "
-      o += "\n"
-    print o
-
-  def GetCellTable(self, headers=True):
-    """Function to return a table of cells.
-
-    The table (list of lists) is converted into a table of cells by this
-    function.
-    Args:
-      headers: A boolean saying whether we want default headers
-
-    Returns:
-      A table of cells with each cell having the properties and string values as
-      requiested by the columns passed in the constructor.
-    """
-    # Generate the cell table, creating a list of dynamic columns on the fly.
-    if not self._out_table:
-      self.GenerateCellTable()
-    if headers:
-      self.AddColumnName()
-      self.AddLabelName()
-    return self._out_table
-
-
-class TablePrinter(object):
-  """Class to print a cell table to the console, file or html."""
-  PLAIN = 0
-  CONSOLE = 1
-  HTML = 2
-  TSV = 3
-  EMAIL = 4
-
-  def __init__(self, table, output_type):
-    """Constructor that stores the cell table and output type."""
-    self._table = table
-    self._output_type = output_type
-
-  # Compute whole-table properties like max-size, etc.
-  def _ComputeStyle(self):
-    self._row_styles = []
-    for row in self._table:
-      row_style = Cell()
-      for cell in row:
-        if cell.color_row:
-          assert cell.color, "Cell color not set but color_row set!"
-          assert not row_style.color, "Multiple row_style.colors found!"
-          row_style.color = cell.color
-        if cell.bgcolor_row:
-          assert cell.bgcolor, "Cell bgcolor not set but bgcolor_row set!"
-          assert not row_style.bgcolor, "Multiple row_style.bgcolors found!"
-          row_style.bgcolor = cell.bgcolor
-      self._row_styles.append(row_style)
-
-    self._column_styles = []
-    if len(self._table) < 2:
-      return
-
-    for i in range(max(len(row) for row in self._table)):
-      column_style = Cell()
-      for row in self._table:
-        if not any([cell.colspan != 1 for cell in row]):
-          column_style.width = max(column_style.width,
-                                   len(row[i].string_value))
-      self._column_styles.append(column_style)
-
-  def _GetBGColorFix(self, color):
-    if self._output_type == self.CONSOLE:
-      rgb = color.GetRGB()
-      prefix, _ = colortrans.rgb2short(rgb)
-      # pylint: disable=anomalous-backslash-in-string
-      prefix = "\033[48;5;%sm" % prefix
-      suffix = "\033[0m"
-    elif self._output_type in [self.EMAIL, self.HTML]:
-      rgb = color.GetRGB()
-      prefix = ("<FONT style=\"BACKGROUND-COLOR:#{0}\">"
-                .format(rgb))
-      suffix = "</FONT>"
-    elif self._output_type in [self.PLAIN, self.TSV]:
-      prefix = ""
-      suffix = ""
-    return prefix, suffix
-
-  def _GetColorFix(self, color):
-    if self._output_type == self.CONSOLE:
-      rgb = color.GetRGB()
-      prefix, _ = colortrans.rgb2short(rgb)
-      # pylint: disable=anomalous-backslash-in-string
-      prefix = "\033[38;5;%sm" % prefix
-      suffix = "\033[0m"
-    elif self._output_type in [self.EMAIL, self.HTML]:
-      rgb = color.GetRGB()
-      prefix = "<FONT COLOR=#{0}>".format(rgb)
-      suffix = "</FONT>"
-    elif self._output_type in [self.PLAIN, self.TSV]:
-      prefix = ""
-      suffix = ""
-    return prefix, suffix
-
-  def Print(self):
-    """Print the table to a console, html, etc.
-
-    Returns:
-      A string that contains the desired representation of the table.
-    """
-    self._ComputeStyle()
-    return self._GetStringValue()
-
-  def _GetCellValue(self, i, j):
-    cell = self._table[i][j]
-    out = cell.string_value
-    raw_width = len(out)
-
-    if cell.color:
-      p, s = self._GetColorFix(cell.color)
-      out = "%s%s%s" % (p, out, s)
-
-    if cell.bgcolor:
-      p, s = self._GetBGColorFix(cell.bgcolor)
-      out = "%s%s%s" % (p, out, s)
-
-    if self._output_type in [self.PLAIN, self.CONSOLE, self.EMAIL]:
-      if cell.width:
-        width = cell.width
-      else:
-        if self._column_styles:
-          width = self._column_styles[j].width
-        else:
-          width = len(cell.string_value)
-      if cell.colspan > 1:
-        width = 0
-        start = 0
-        for k in range(j):
-          start += self._table[i][k].colspan
-        for k in range(cell.colspan):
-          width += self._column_styles[start + k].width
-      if width > raw_width:
-        padding = ("%" + str(width - raw_width) + "s") % ""
-        out = padding + out
-
-    if self._output_type == self.HTML:
-      if cell.header:
-        tag = "th"
-      else:
-        tag = "td"
-      out = "<{0} colspan = \"{2}\"> {1} </{0}>".format(tag, out, cell.colspan)
-
-    return out
-
-  def _GetHorizontalSeparator(self):
-    if self._output_type in [self.CONSOLE, self.PLAIN, self.EMAIL]:
-      return " "
-    if self._output_type == self.HTML:
-      return ""
-    if self._output_type == self.TSV:
-      return "\t"
-
-  def _GetVerticalSeparator(self):
-    if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
-      return "\n"
-    if self._output_type == self.HTML:
-      return "</tr>\n<tr>"
-
-  def _GetPrefix(self):
-    if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
-      return ""
-    if self._output_type == self.HTML:
-      return "<p></p><table id=\"box-table-a\">\n<tr>"
-
-  def _GetSuffix(self):
-    if self._output_type in [self.PLAIN, self.CONSOLE, self.TSV, self.EMAIL]:
-      return ""
-    if self._output_type == self.HTML:
-      return "</tr>\n</table>"
-
-  def _GetStringValue(self):
-    o = ""
-    o += self._GetPrefix()
-    for i in range(len(self._table)):
-      row = self._table[i]
-      # Apply row color and bgcolor.
-      p = s = bgp = bgs = ""
-      if self._row_styles[i].bgcolor:
-        bgp, bgs = self._GetBGColorFix(self._row_styles[i].bgcolor)
-      if self._row_styles[i].color:
-        p, s = self._GetColorFix(self._row_styles[i].color)
-      o += p + bgp
-      for j in range(len(row)):
-        out = self._GetCellValue(i, j)
-        o += out + self._GetHorizontalSeparator()
-      o += s + bgs
-      o += self._GetVerticalSeparator()
-    o += self._GetSuffix()
-    return o
-
-
-# Some common drivers
-def GetSimpleTable(table, out_to=TablePrinter.CONSOLE):
-  """Prints a simple table.
-
-  This is used by code that has a very simple list-of-lists and wants to produce
-  a table with ameans, a percentage ratio of ameans and a colorbox.
-
-  Args:
-    table: a list of lists.
-    out_to: specify the fomat of output. Currently it supports HTML and CONSOLE.
-
-  Returns:
-    A string version of the table that can be printed to the console.
-
-  Example:
-    GetSimpleConsoleTable([["binary", "b1", "b2"],["size", "300", "400"]])
-    will produce a colored table that can be printed to the console.
-  """
-  columns = [
-      Column(AmeanResult(),
-             Format()),
-      Column(AmeanRatioResult(),
-             PercentFormat()),
-      Column(AmeanRatioResult(),
-             ColorBoxFormat()),
-      ]
-  our_table = [table[0]]
-  for row in table[1:]:
-    our_row = [row[0]]
-    for v in row[1:]:
-      our_row.append([v])
-    our_table.append(our_row)
-
-  tf = TableFormatter(our_table, columns)
-  cell_table = tf.GetCellTable()
-  tp = TablePrinter(cell_table, out_to)
-  return tp.Print()
-
-
-# pylint: disable=redefined-outer-name
-def GetComplexTable(runs, labels, out_to=TablePrinter.CONSOLE):
-  """Prints a complex table.
-
-  This can be used to generate a table with arithmetic mean, standard deviation,
-  coefficient of variation, p-values, etc.
-
-  Args:
-    runs: A list of lists with data to tabulate.
-    labels: A list of labels that correspond to the runs.
-    out_to: specifies the format of the table (example CONSOLE or HTML).
-
-  Returns:
-    A string table that can be printed to the console or put in an HTML file.
-  """
-  tg = TableGenerator(runs, labels, TableGenerator.SORT_BY_VALUES_DESC)
-  table = tg.GetTable()
-  columns = [Column(LiteralResult(),
-                    Format(),
-                    "Literal"),
-             Column(AmeanResult(),
-                    Format()),
-             Column(StdResult(),
-                    Format()),
-             Column(CoeffVarResult(),
-                    CoeffVarFormat()),
-             Column(NonEmptyCountResult(),
-                    Format()),
-             Column(AmeanRatioResult(),
-                    PercentFormat()),
-             Column(AmeanRatioResult(),
-                    RatioFormat()),
-             Column(GmeanRatioResult(),
-                    RatioFormat()),
-             Column(PValueResult(),
-                    PValueFormat()),
-            ]
-  tf = TableFormatter(table, columns)
-  cell_table = tf.GetCellTable()
-  tp = TablePrinter(cell_table, out_to)
-  return tp.Print()
-
-if __name__ == "__main__":
-  # Run a few small tests here.
-  runs = [[{"k1": "10", "k2": "12", "k5": "40", "k6": "40",
-            "ms_1": "20", "k7": "FAIL", "k8": "PASS", "k9": "PASS",
-            "k10": "0"},
-           {"k1": "13", "k2": "14", "k3": "15", "ms_1": "10", "k8": "PASS",
-            "k9": "FAIL", "k10": "0"}],
-          [{"k1": "50", "k2": "51", "k3": "52", "k4": "53", "k5": "35", "k6":
-            "45", "ms_1": "200", "ms_2": "20", "k7": "FAIL", "k8": "PASS", "k9":
-            "PASS"}]]
-  labels = ["vanilla", "modified"]
-  t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
-  print t
-  email = GetComplexTable(runs, labels, TablePrinter.EMAIL)
-
-  runs = [[{"k1": "1"}, {"k1": "1.1"}, {"k1": "1.2"}],
-          [{"k1": "5"}, {"k1": "5.1"}, {"k1": "5.2"}]]
-  t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
-  print t
-
-  simple_table = [
-      ["binary", "b1", "b2", "b3"],
-      ["size", 100, 105, 108],
-      ["rodata", 100, 80, 70],
-      ["data", 100, 100, 100],
-      ["debug", 100, 140, 60],
-      ]
-  t = GetSimpleTable(simple_table)
-  print t
-  email += GetSimpleTable(simple_table, TablePrinter.HTML)
-  email_to = [getpass.getuser()]
-  email = "<pre style='font-size: 13px'>%s</pre>" % email
-  EmailSender().SendEmail(email_to, "SimpleTableTest", email, msg_type="html")
diff --git a/v14/utils/tabulator_test.py b/v14/utils/tabulator_test.py
deleted file mode 100644
index 16406107..00000000
--- a/v14/utils/tabulator_test.py
+++ /dev/null
@@ -1,135 +0,0 @@
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""Tests for the tabulator module."""
-
-__author__ = "asharif@google.com (Ahmad Sharif)"
-
-# System modules
-import unittest
-
-# Local modules
-import tabulator
-
-
-class TabulatorTest(unittest.TestCase):
-  def testResult(self):
-    table = ["k1", ["1", "3"], ["55"]]
-    result = tabulator.Result()
-    cell = tabulator.Cell()
-    result.Compute(cell, table[2], table[1])
-    expected = " ".join([str(float(v)) for v in table[2]])
-    self.assertTrue(cell.value == expected)
-
-    result = tabulator.AmeanResult()
-    cell = tabulator.Cell()
-    result.Compute(cell, table[2], table[1])
-    self.assertTrue(cell.value == float(table[2][0]))
-
-  def testStringMean(self):
-    smr = tabulator.StringMeanResult()
-    cell = tabulator.Cell()
-    value = "PASS"
-    values = [value for _ in range(3)]
-    smr.Compute(cell, values, None)
-    self.assertTrue(cell.value == value)
-    values.append("FAIL")
-    smr.Compute(cell, values, None)
-    self.assertTrue(cell.value == "?")
-
-  def testStorageFormat(self):
-    sf = tabulator.StorageFormat()
-    cell = tabulator.Cell()
-    base = 1024.0
-    cell.value = base
-    sf.Compute(cell)
-    self.assertTrue(cell.string_value == "1.0K")
-    cell.value = base**2
-    sf.Compute(cell)
-    self.assertTrue(cell.string_value == "1.0M")
-    cell.value = base**3
-    sf.Compute(cell)
-    self.assertTrue(cell.string_value == "1.0G")
-
-  def testLerp(self):
-    c1 = tabulator.Color(0, 0, 0, 0)
-    c2 = tabulator.Color(255, 0, 0, 0)
-    c3 = tabulator.Color.Lerp(0.5, c1, c2)
-    self.assertTrue(c3.r == 127.5)
-    self.assertTrue(c3.g == 0)
-    self.assertTrue(c3.b == 0)
-    self.assertTrue(c3.a == 0)
-    c3.Round()
-    self.assertTrue(c3.r == 127)
-
-  def testGmean(self):
-    a = [1.0e+308] * 3
-    b = tabulator.Result()._GetGmean(a)
-    self.assertTrue(b >= 0.99e+308 and b <= 1.01e+308)
-
-  def testTableGenerator(self):
-    runs = [[{"k1": "10", "k2": "12"},
-             {"k1": "13", "k2": "14", "k3": "15"}],
-            [{"k1": "50", "k2": "51", "k3": "52", "k4": "53"}]]
-    labels = ["vanilla", "modified"]
-    tg = tabulator.TableGenerator(runs, labels)
-    table = tg.GetTable()
-    header = table.pop(0)
-
-    self.assertTrue(header == ["keys", "vanilla", "modified"])
-    row = table.pop(0)
-    self.assertTrue(row == ["k1", ["10", "13"], ["50"]])
-    row = table.pop(0)
-    self.assertTrue(row == ["k2", ["12", "14"], ["51"]])
-    row = table.pop(0)
-    self.assertTrue(row == ["k3", [None, "15"], ["52"]])
-    row = table.pop(0)
-    self.assertTrue(row == ["k4", [None, None], ["53"]])
-
-    table = tg.GetTable()
-    columns = [
-        tabulator.Column(tabulator.AmeanResult(),
-                         tabulator.Format()),
-        tabulator.Column(tabulator.AmeanRatioResult(),
-                         tabulator.PercentFormat()),
-        ]
-    tf = tabulator.TableFormatter(table, columns)
-    table = tf.GetCellTable()
-    self.assertTrue(table)
-
-  def testColspan(self):
-    simple_table = [
-        ["binary", "b1", "b2", "b3"],
-        ["size", 100, 105, 108],
-        ["rodata", 100, 80, 70],
-        ["data", 100, 100, 100],
-        ["debug", 100, 140, 60],
-        ]
-    columns = [
-        tabulator.Column(tabulator.AmeanResult(),
-                         tabulator.Format()),
-        tabulator.Column(tabulator.MinResult(),
-                         tabulator.Format()),
-        tabulator.Column(tabulator.AmeanRatioResult(),
-                         tabulator.PercentFormat()),
-        tabulator.Column(tabulator.AmeanRatioResult(),
-                         tabulator.ColorBoxFormat()),
-        ]
-    our_table = [simple_table[0]]
-    for row in simple_table[1:]:
-      our_row = [row[0]]
-      for v in row[1:]:
-        our_row.append([v])
-      our_table.append(our_row)
-
-    tf = tabulator.TableFormatter(our_table, columns)
-    cell_table = tf.GetCellTable()
-    self.assertTrue(cell_table[0][0].colspan == 1)
-    self.assertTrue(cell_table[0][1].colspan == 2)
-    self.assertTrue(cell_table[0][2].colspan == 4)
-    self.assertTrue(cell_table[0][3].colspan == 4)
-    for row in cell_table[1:]:
-      for cell in row:
-        self.assertTrue(cell.colspan == 1)
-
-if __name__ == "__main__":
-  unittest.main()
diff --git a/v14/utils/timeline.py b/v14/utils/timeline.py
deleted file mode 100644
index fa75ba01..00000000
--- a/v14/utils/timeline.py
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/usr/bin/python2.6
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-
-"""Tools for recording and reporting timeline of benchmark_run."""
-
-__author__ = 'yunlian@google.com (Yunlian Jiang)'
-
-import time
-
-
-class Event(object):
-  def __init__(self, name='', cur_time=0):
-    self.name = name
-    self.timestamp = cur_time
-
-
-class Timeline(object):
-  """Use a dict to store the timeline."""
-
-  def __init__(self):
-    self.events = []
-
-  def Record(self, event):
-    for e in self.events:
-      assert e.name != event, ('The event {0} is already recorded.'
-                               .format(event))
-    cur_event = Event(name=event, cur_time=time.time())
-    self.events.append(cur_event)
-
-  def GetEvents(self):
-    return([e.name for e in self.events])
-
-  def GetEventDict(self):
-    tl = {}
-    for e in self.events:
-      tl[e.name] = e.timestamp
-    return tl
-
-  def GetEventTime(self, event):
-    for e in self.events:
-      if e.name == event:
-        return e.timestamp
-    raise IndexError, 'The event {0} is not recorded'.format(event)
-
-  def GetLastEventTime(self):
-    return self.events[-1].timestamp
-
-  def GetLastEvent(self):
-    return self.events[-1].name
diff --git a/v14/utils/timeline_test.py b/v14/utils/timeline_test.py
deleted file mode 100644
index 1f4d178a..00000000
--- a/v14/utils/timeline_test.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright 2012 Google Inc. All Rights Reserved.
-
-"""Tests for time_line.py."""
-
-__author__ = 'yunlian@google.com (Yunlian Jiang)'
-
-import time
-import unittest
-
-import timeline
-
-
-class TimeLineTest(unittest.TestCase):
-
-  def testRecord(self):
-    tl = timeline.Timeline()
-    tl.Record('A')
-    t = time.time()
-    t1 = tl.events[0].timestamp
-    self.assertEqual(int(t1-t), 0)
-    self.assertRaises(AssertionError, tl.Record, 'A')
-
-  def testGetEvents(self):
-    tl = timeline.Timeline()
-    tl.Record('A')
-    e = tl.GetEvents()
-    self.assertEqual(e, ['A'])
-    tl.Record('B')
-    e = tl.GetEvents()
-    self.assertEqual(e, ['A', 'B'])
-
-  def testGetEventTime(self):
-    tl = timeline.Timeline()
-    tl.Record('A')
-    t = time.time()
-    t1 = tl.GetEventTime('A')
-    self.assertEqual(int(t1-t), 0)
-    self.assertRaises(IndexError, tl.GetEventTime, 'B')
-
-  def testGetLastEventTime(self):
-    tl = timeline.Timeline()
-    self.assertRaises(IndexError, tl.GetLastEventTime)
-    tl.Record('A')
-    t = time.time()
-    t1 = tl.GetLastEventTime()
-    self.assertEqual(int(t1-t), 0)
-    time.sleep(2)
-    tl.Record('B')
-    t = time.time()
-    t1 = tl.GetLastEventTime()
-    self.assertEqual(int(t1-t), 0)
-
-if __name__ == '__main__':
-  unittest.main()