Revert wrong svn copy.

24 files changed, 0 insertions, 10328 deletions

diff --git a/Tools/pybench/pybench-2.0/Arithmetic.py b/Tools/pybench/pybench-2.0/Arithmetic.py
deleted file mode 100644
index 6923b4b..0000000
--- a/Tools/pybench/pybench-2.0/Arithmetic.py
+++ /dev/null
@@ -1,777 +0,0 @@
-from pybench import Test
-
-class SimpleIntegerArithmetic(Test):
-
-    version = 2.0
-    operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
-    rounds = 120000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            a = 2
-            b = 3
-            c = 3
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-class SimpleFloatArithmetic(Test):
-
-    version = 2.0
-    operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
-    rounds = 120000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            a = 2.1
-            b = 3.3332
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2.1
-            b = 3.3332
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2.1
-            b = 3.3332
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2.1
-            b = 3.3332
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2.1
-            b = 3.3332
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-class SimpleIntFloatArithmetic(Test):
-
-    version = 2.0
-    operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
-    rounds = 120000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            a = 2
-            b = 3
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2
-            b = 3
-            c = 3.14159
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class SimpleLongArithmetic(Test):
-
-    version = 2.0
-    operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
-    rounds = 60000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            a = 2220001L
-            b = 100001L
-            c = 30005L
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2220001L
-            b = 100001L
-            c = 30005L
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2220001L
-            b = 100001L
-            c = 30005L
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2220001L
-            b = 100001L
-            c = 30005L
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2220001L
-            b = 100001L
-            c = 30005L
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-class SimpleComplexArithmetic(Test):
-
-    version = 2.0
-    operations = 5 * (3 + 5 + 5 + 3 + 3 + 3)
-    rounds = 80000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            a = 2 + 3j
-            b = 2.5 + 4.5j
-            c = 1.2 + 6.2j
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2 + 3j
-            b = 2.5 + 4.5j
-            c = 1.2 + 6.2j
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2 + 3j
-            b = 2.5 + 4.5j
-            c = 1.2 + 6.2j
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2 + 3j
-            b = 2.5 + 4.5j
-            c = 1.2 + 6.2j
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            a = 2 + 3j
-            b = 2.5 + 4.5j
-            c = 1.2 + 6.2j
-
-            c = a + b
-            c = b + c
-            c = c + a
-            c = a + b
-            c = b + c
-
-            c = c - a
-            c = a - b
-            c = b - c
-            c = c - a
-            c = b - c
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-            c = a * b
-            c = b * a
-            c = c * b
-
-            c = a / b
-            c = b / a
-            c = c / b
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Calls.py b/Tools/pybench/pybench-2.0/Calls.py
deleted file mode 100644
index fa18314..0000000
--- a/Tools/pybench/pybench-2.0/Calls.py
+++ /dev/null
@@ -1,504 +0,0 @@
-from pybench import Test
-
-class PythonFunctionCalls(Test):
-
-    version = 2.0
-    operations = 5*(1+4+4+2)
-    rounds = 60000
-
-    def test(self):
-
-        global f,f1,g,h
-
-        # define functions
-        def f():
-            pass
-
-        def f1(x):
-            pass
-
-        def g(a,b,c):
-            return a,b,c
-
-        def h(a,b,c,d=1,e=2,f=3):
-            return d,e,f
-
-        # do calls
-        for i in xrange(self.rounds):
-
-            f()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            h(i,i,3,i,i)
-            h(i,i,i,2,i,3)
-
-            f()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            h(i,i,3,i,i)
-            h(i,i,i,2,i,3)
-
-            f()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            h(i,i,3,i,i)
-            h(i,i,i,2,i,3)
-
-            f()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            h(i,i,3,i,i)
-            h(i,i,i,2,i,3)
-
-            f()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            g(i,i,i)
-            h(i,i,3,i,i)
-            h(i,i,i,2,i,3)
-
-    def calibrate(self):
-
-        global f,f1,g,h
-
-        # define functions
-        def f():
-            pass
-
-        def f1(x):
-            pass
-
-        def g(a,b,c):
-            return a,b,c
-
-        def h(a,b,c,d=1,e=2,f=3):
-            return d,e,f
-
-        # do calls
-        for i in xrange(self.rounds):
-            pass
-
-###
-
-class BuiltinFunctionCalls(Test):
-
-    version = 2.0
-    operations = 5*(2+5+5+5)
-    rounds = 60000
-
-    def test(self):
-
-        # localize functions
-        f0 = globals
-        f1 = hash
-        f2 = cmp
-        f3 = range
-
-        # do calls
-        for i in xrange(self.rounds):
-
-            f0()
-            f0()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-
-            f0()
-            f0()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-
-            f0()
-            f0()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-
-            f0()
-            f0()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-
-            f0()
-            f0()
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f1(i)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f2(1,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-            f3(1,3,2)
-
-    def calibrate(self):
-
-        # localize functions
-        f0 = dir
-        f1 = hash
-        f2 = range
-        f3 = range
-
-        # do calls
-        for i in xrange(self.rounds):
-            pass
-
-###
-
-class PythonMethodCalls(Test):
-
-    version = 2.0
-    operations = 5*(6 + 5 + 4)
-    rounds = 30000
-
-    def test(self):
-
-        class c:
-
-            x = 2
-            s = 'string'
-
-            def f(self):
-
-                return self.x
-
-            def j(self,a,b):
-
-                self.y = a
-                self.t = b
-                return self.y
-
-            def k(self,a,b,c=3):
-
-                self.y = a
-                self.s = b
-                self.t = c
-
-        o = c()
-
-        for i in xrange(self.rounds):
-
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.j(i,i)
-            o.j(i,i)
-            o.j(i,2)
-            o.j(i,2)
-            o.j(2,2)
-            o.k(i,i)
-            o.k(i,2)
-            o.k(i,2,3)
-            o.k(i,i,c=4)
-
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.j(i,i)
-            o.j(i,i)
-            o.j(i,2)
-            o.j(i,2)
-            o.j(2,2)
-            o.k(i,i)
-            o.k(i,2)
-            o.k(i,2,3)
-            o.k(i,i,c=4)
-
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.j(i,i)
-            o.j(i,i)
-            o.j(i,2)
-            o.j(i,2)
-            o.j(2,2)
-            o.k(i,i)
-            o.k(i,2)
-            o.k(i,2,3)
-            o.k(i,i,c=4)
-
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.j(i,i)
-            o.j(i,i)
-            o.j(i,2)
-            o.j(i,2)
-            o.j(2,2)
-            o.k(i,i)
-            o.k(i,2)
-            o.k(i,2,3)
-            o.k(i,i,c=4)
-
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.f()
-            o.j(i,i)
-            o.j(i,i)
-            o.j(i,2)
-            o.j(i,2)
-            o.j(2,2)
-            o.k(i,i)
-            o.k(i,2)
-            o.k(i,2,3)
-            o.k(i,i,c=4)
-
-    def calibrate(self):
-
-        class c:
-
-            x = 2
-            s = 'string'
-
-            def f(self):
-
-                return self.x
-
-            def j(self,a,b):
-
-                self.y = a
-                self.t = b
-
-            def k(self,a,b,c=3):
-
-                self.y = a
-                self.s = b
-                self.t = c
-
-        o = c
-
-        for i in xrange(self.rounds):
-            pass
-
-###
-
-class Recursion(Test):
-
-    version = 2.0
-    operations = 5
-    rounds = 100000
-
-    def test(self):
-
-        global f
-
-        def f(x):
-
-            if x > 1:
-                return f(x-1)
-            return 1
-
-        for i in xrange(self.rounds):
-            f(10)
-            f(10)
-            f(10)
-            f(10)
-            f(10)
-
-    def calibrate(self):
-
-        global f
-
-        def f(x):
-
-            if x > 0:
-                return f(x-1)
-            return 1
-
-        for i in xrange(self.rounds):
-            pass
-
-
-### Test to make Fredrik happy...
-
-if __name__ == '__main__':
-    import timeit
-    if 0:
-        timeit.TestClass = PythonFunctionCalls
-        timeit.main(['-s', 'test = TestClass(); test.rounds = 1000',
-                     'test.test()'])
-    else:
-        setup = """\
-global f,f1,g,h
-
-# define functions
-def f():
-    pass
-
-def f1(x):
-    pass
-
-def g(a,b,c):
-    return a,b,c
-
-def h(a,b,c,d=1,e=2,f=3):
-    return d,e,f
-
-i = 1
-"""
-        test = """\
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-
-f()
-f1(i)
-f1(i)
-f1(i)
-f1(i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-g(i,i,i)
-h(i,i,3,i,i)
-h(i,i,i,2,i,3)
-"""
-
-        timeit.main(['-s', setup,
-                     test])
-                     
-        
diff --git a/Tools/pybench/pybench-2.0/CommandLine.py b/Tools/pybench/pybench-2.0/CommandLine.py
deleted file mode 100644
index 6601be5..0000000
--- a/Tools/pybench/pybench-2.0/CommandLine.py
+++ /dev/null
@@ -1,634 +0,0 @@
-""" CommandLine - Get and parse command line options
-
-    NOTE: This still is very much work in progress !!!
-
-    Different version are likely to be incompatible.
-
-    TODO:
-
-    * Incorporate the changes made by (see Inbox)
-    * Add number range option using srange()
-
-"""
-
-__copyright__ = """\
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-See the documentation for further information on copyrights,
-or contact the author. All Rights Reserved.
-"""
-
-__version__ = '1.2'
-
-import sys, getopt, string, glob, os, re, exceptions, traceback
-
-### Helpers
-
-def _getopt_flags(options):
-
-    """ Convert the option list to a getopt flag string and long opt
-        list
-
-    """
-    s = []
-    l = []
-    for o in options:
-        if o.prefix == '-':
-            # short option
-            s.append(o.name)
-            if o.takes_argument:
-                s.append(':')
-        else:
-            # long option
-            if o.takes_argument:
-                l.append(o.name+'=')
-            else:
-                l.append(o.name)
-    return string.join(s,''),l
-
-def invisible_input(prompt='>>> '):
-
-    """ Get raw input from a terminal without echoing the characters to
-        the terminal, e.g. for password queries.
-
-    """
-    import getpass
-    entry = getpass.getpass(prompt)
-    if entry is None:
-        raise KeyboardInterrupt
-    return entry
-
-def fileopen(name, mode='wb', encoding=None):
-
-    """ Open a file using mode.
-
-        Default mode is 'wb' meaning to open the file for writing in
-        binary mode. If encoding is given, I/O to and from the file is
-        transparently encoded using the given encoding.
-
-        Files opened for writing are chmod()ed to 0600.
-
-    """
-    if name == 'stdout':
-        return sys.stdout
-    elif name == 'stderr':
-        return sys.stderr
-    elif name == 'stdin':
-        return sys.stdin
-    else:
-        if encoding is not None:
-            import codecs
-            f = codecs.open(name, mode, encoding)
-        else:
-            f = open(name, mode)
-        if 'w' in mode:
-            os.chmod(name, 0600)
-        return f
-
-def option_dict(options):
-
-    """ Return a dictionary mapping option names to Option instances.
-    """
-    d = {}
-    for option in options:
-        d[option.name] = option
-    return d
-
-# Alias
-getpasswd = invisible_input
-
-_integerRE = re.compile('\s*(-?\d+)\s*$')
-_integerRangeRE = re.compile('\s*(-?\d+)\s*-\s*(-?\d+)\s*$')
-
-def srange(s,
-
-           split=string.split,integer=_integerRE,
-           integerRange=_integerRangeRE):
-
-    """ Converts a textual representation of integer numbers and ranges
-        to a Python list.
-
-        Supported formats: 2,3,4,2-10,-1 - -3, 5 - -2
-
-        Values are appended to the created list in the order specified
-        in the string.
-
-    """
-    l = []
-    append = l.append
-    for entry in split(s,','):
-        m = integer.match(entry)
-        if m:
-            append(int(m.groups()[0]))
-            continue
-        m = integerRange.match(entry)
-        if m:
-            start,end = map(int,m.groups())
-            l[len(l):] = range(start,end+1)
-    return l
-
-def abspath(path,
-
-            expandvars=os.path.expandvars,expanduser=os.path.expanduser,
-            join=os.path.join,getcwd=os.getcwd):
-
-    """ Return the corresponding absolute path for path.
-
-        path is expanded in the usual shell ways before
-        joining it with the current working directory.
-
-    """
-    try:
-        path = expandvars(path)
-    except AttributeError:
-        pass
-    try:
-        path = expanduser(path)
-    except AttributeError:
-        pass
-    return join(getcwd(), path)
-
-### Option classes
-
-class Option:
-
-    """ Option base class. Takes no argument.
-
-    """
-    default = None
-    helptext = ''
-    prefix = '-'
-    takes_argument = 0
-    has_default = 0
-    tab = 15
-
-    def __init__(self,name,help=None):
-
-        if not name[:1] == '-':
-            raise TypeError,'option names must start with "-"'
-        if name[1:2] == '-':
-            self.prefix = '--'
-            self.name = name[2:]
-        else:
-            self.name = name[1:]
-        if help:
-            self.help = help
-
-    def __str__(self):
-
-        o = self
-        name = o.prefix + o.name
-        if o.takes_argument:
-            name = name + ' arg'
-        if len(name) > self.tab:
-            name = name + '\n' + ' ' * (self.tab + 1 + len(o.prefix))
-        else:
-            name = '%-*s ' % (self.tab, name)
-        description = o.help
-        if o.has_default:
-            description = description + ' (%s)' % o.default
-        return '%s %s' % (name, description)
-
-class ArgumentOption(Option):
-
-    """ Option that takes an argument.
-
-        An optional default argument can be given.
-
-    """
-    def __init__(self,name,help=None,default=None):
-
-        # Basemethod
-        Option.__init__(self,name,help)
-
-        if default is not None:
-            self.default = default
-            self.has_default = 1
-        self.takes_argument = 1
-
-class SwitchOption(Option):
-
-    """ Options that can be on or off. Has an optional default value.
-
-    """
-    def __init__(self,name,help=None,default=None):
-
-        # Basemethod
-        Option.__init__(self,name,help)
-
-        if default is not None:
-            self.default = default
-            self.has_default = 1
-
-### Application baseclass
-
-class Application:
-
-    """ Command line application interface with builtin argument
-        parsing.
-
-    """
-    # Options the program accepts (Option instances)
-    options = []
-
-    # Standard settings; these are appended to options in __init__
-    preset_options = [SwitchOption('-v',
-                                   'generate verbose output'),
-                      SwitchOption('-h',
-                                   'show this help text'),
-                      SwitchOption('--help',
-                                   'show this help text'),
-                      SwitchOption('--debug',
-                                   'enable debugging'),
-                      SwitchOption('--copyright',
-                                   'show copyright'),
-                      SwitchOption('--examples',
-                                   'show examples of usage')]
-
-    # The help layout looks like this:
-    # [header]   - defaults to ''
-    #
-    # [synopsis] - formatted as '<self.name> %s' % self.synopsis
-    #
-    # options:
-    # [options]  - formatted from self.options
-    #
-    # [version]  - formatted as 'Version:\n %s' % self.version, if given
-    #
-    # [about]    - defaults to ''
-    #
-    # Note: all fields that do not behave as template are formatted
-    #       using the instances dictionary as substitution namespace,
-    #       e.g. %(name)s will be replaced by the applications name.
-    #
-
-    # Header (default to program name)
-    header = ''
-
-    # Name (defaults to program name)
-    name = ''
-
-    # Synopsis (%(name)s is replaced by the program name)
-    synopsis = '%(name)s [option] files...'
-
-    # Version (optional)
-    version = ''
-
-    # General information printed after the possible options (optional)
-    about = ''
-
-    # Examples of usage to show when the --examples option is given (optional)
-    examples = ''
-
-    # Copyright to show
-    copyright = __copyright__
-
-    # Apply file globbing ?
-    globbing = 1
-
-    # Generate debug output ?
-    debug = 0
-
-    # Generate verbose output ?
-    verbose = 0
-
-    # Internal errors to catch
-    InternalError = exceptions.Exception
-
-    # Instance variables:
-    values = None       # Dictionary of passed options (or default values)
-                        # indexed by the options name, e.g. '-h'
-    files = None        # List of passed filenames
-    optionlist = None   # List of passed options
-
-    def __init__(self,argv=None):
-
-        # Setup application specs
-        if argv is None:
-            argv = sys.argv
-        self.filename = os.path.split(argv[0])[1]
-        if not self.name:
-            self.name = os.path.split(self.filename)[1]
-        else:
-            self.name = self.name
-        if not self.header:
-            self.header = self.name
-        else:
-            self.header = self.header
-
-        # Init .arguments list
-        self.arguments = argv[1:]
-
-        # Setup Option mapping
-        self.option_map = option_dict(self.options)
-
-        # Append preset options
-        for option in self.preset_options:
-            if not self.option_map.has_key(option.name):
-                self.add_option(option)
-
-        # Init .files list
-        self.files = []
-
-        # Start Application
-        try:
-            # Process startup
-            rc = self.startup()
-            if rc is not None:
-                raise SystemExit,rc
-
-            # Parse command line
-            rc = self.parse()
-            if rc is not None:
-                raise SystemExit,rc
-
-            # Start application
-            rc = self.main()
-            if rc is None:
-                rc = 0
-
-        except SystemExit,rc:
-            pass
-
-        except KeyboardInterrupt:
-            print
-            print '* User Break'
-            print
-            rc = 1
-
-        except self.InternalError:
-            print
-            print '* Internal Error (use --debug to display the traceback)'
-            if self.debug:
-                print
-                traceback.print_exc(20, sys.stdout)
-            elif self.verbose:
-                print '  %s: %s' % sys.exc_info()[:2]
-            print
-            rc = 1
-
-        raise SystemExit,rc
-
-    def add_option(self, option):
-
-        """ Add a new Option instance to the Application dynamically.
-
-            Note that this has to be done *before* .parse() is being
-            executed.
-
-        """
-        self.options.append(option)
-        self.option_map[option.name] = option
-
-    def startup(self):
-
-        """ Set user defined instance variables.
-
-            If this method returns anything other than None, the
-            process is terminated with the return value as exit code.
-
-        """
-        return None
-
-    def exit(self, rc=0):
-
-        """ Exit the program.
-
-            rc is used as exit code and passed back to the calling
-            program. It defaults to 0 which usually means: OK.
-
-        """
-        raise SystemExit, rc
-
-    def parse(self):
-
-        """ Parse the command line and fill in self.values and self.files.
-
-            After having parsed the options, the remaining command line
-            arguments are interpreted as files and passed to .handle_files()
-            for processing.
-
-            As final step the option handlers are called in the order
-            of the options given on the command line.
-
-        """
-        # Parse arguments
-        self.values = values = {}
-        for o in self.options:
-            if o.has_default:
-                values[o.prefix+o.name] = o.default
-            else:
-                values[o.prefix+o.name] = 0
-        flags,lflags = _getopt_flags(self.options)
-        try:
-            optlist,files = getopt.getopt(self.arguments,flags,lflags)
-            if self.globbing:
-                l = []
-                for f in files:
-                    gf = glob.glob(f)
-                    if not gf:
-                        l.append(f)
-                    else:
-                        l[len(l):] = gf
-                files = l
-            self.optionlist = optlist
-            self.files = files + self.files
-        except getopt.error,why:
-            self.help(why)
-            sys.exit(1)
-
-        # Call file handler
-        rc = self.handle_files(self.files)
-        if rc is not None:
-            sys.exit(rc)
-
-        # Call option handlers
-        for optionname, value in optlist:
-
-            # Try to convert value to integer
-            try:
-                value = string.atoi(value)
-            except ValueError:
-                pass
-
-            # Find handler and call it (or count the number of option
-            # instances on the command line)
-            handlername = 'handle' + string.replace(optionname, '-', '_')
-            try:
-                handler = getattr(self, handlername)
-            except AttributeError:
-                if value == '':
-                    # count the number of occurances
-                    if values.has_key(optionname):
-                        values[optionname] = values[optionname] + 1
-                    else:
-                        values[optionname] = 1
-                else:
-                    values[optionname] = value
-            else:
-                rc = handler(value)
-                if rc is not None:
-                    raise SystemExit, rc
-
-        # Apply final file check (for backward compatibility)
-        rc = self.check_files(self.files)
-        if rc is not None:
-            sys.exit(rc)
-
-    def check_files(self,filelist):
-
-        """ Apply some user defined checks on the files given in filelist.
-
-            This may modify filelist in place. A typical application
-            is checking that at least n files are given.
-
-            If this method returns anything other than None, the
-            process is terminated with the return value as exit code.
-
-        """
-        return None
-
-    def help(self,note=''):
-
-        self.print_header()
-        if self.synopsis:
-            print 'Synopsis:'
-            # To remain backward compatible:
-            try:
-                synopsis = self.synopsis % self.name
-            except (NameError, KeyError, TypeError):
-                synopsis = self.synopsis % self.__dict__
-            print ' ' + synopsis
-        print
-        self.print_options()
-        if self.version:
-            print 'Version:'
-            print ' %s' % self.version
-            print
-        if self.about:
-            print string.strip(self.about % self.__dict__)
-            print
-        if note:
-            print '-'*72
-            print 'Note:',note
-            print
-
-    def notice(self,note):
-
-        print '-'*72
-        print 'Note:',note
-        print '-'*72
-        print
-
-    def print_header(self):
-
-        print '-'*72
-        print self.header % self.__dict__
-        print '-'*72
-        print
-
-    def print_options(self):
-
-        options = self.options
-        print 'Options and default settings:'
-        if not options:
-            print '  None'
-            return
-        long = filter(lambda x: x.prefix == '--', options)
-        short = filter(lambda x: x.prefix == '-', options)
-        items = short + long
-        for o in options:
-            print ' ',o
-        print
-
-    #
-    # Example handlers:
-    #
-    # If a handler returns anything other than None, processing stops
-    # and the return value is passed to sys.exit() as argument.
-    #
-
-    # File handler
-    def handle_files(self,files):
-
-        """ This may process the files list in place.
-        """
-        return None
-
-    # Short option handler
-    def handle_h(self,arg):
-
-        self.help()
-        return 0
-
-    def handle_v(self, value):
-
-        """ Turn on verbose output.
-        """
-        self.verbose = 1
-
-    # Handlers for long options have two underscores in their name
-    def handle__help(self,arg):
-
-        self.help()
-        return 0
-
-    def handle__debug(self,arg):
-
-        self.debug = 1
-        # We don't want to catch internal errors:
-        self.InternalError = None
-
-    def handle__copyright(self,arg):
-
-        self.print_header()
-        print string.strip(self.copyright % self.__dict__)
-        print
-        return 0
-
-    def handle__examples(self,arg):
-
-        self.print_header()
-        if self.examples:
-            print 'Examples:'
-            print
-            print string.strip(self.examples % self.__dict__)
-            print
-        else:
-            print 'No examples available.'
-            print
-        return 0
-
-    def main(self):
-
-        """ Override this method as program entry point.
-
-            The return value is passed to sys.exit() as argument.  If
-            it is None, 0 is assumed (meaning OK). Unhandled
-            exceptions are reported with exit status code 1 (see
-            __init__ for further details).
-
-        """
-        return None
-
-# Alias
-CommandLine = Application
-
-def _test():
-
-    class MyApplication(Application):
-        header = 'Test Application'
-        version = __version__
-        options = [Option('-v','verbose')]
-
-        def handle_v(self,arg):
-            print 'VERBOSE, Yeah !'
-
-    cmd = MyApplication()
-    if not cmd.values['-h']:
-        cmd.help()
-    print 'files:',cmd.files
-    print 'Bye...'
-
-if __name__ == '__main__':
-    _test()
diff --git a/Tools/pybench/pybench-2.0/Constructs.py b/Tools/pybench/pybench-2.0/Constructs.py
deleted file mode 100644
index 5105461..0000000
--- a/Tools/pybench/pybench-2.0/Constructs.py
+++ /dev/null
@@ -1,564 +0,0 @@
-from pybench import Test
-
-class IfThenElse(Test):
-
-    version = 2.0
-    operations = 30*3 # hard to say...
-    rounds = 150000
-
-    def test(self):
-
-        a,b,c = 1,2,3
-        for i in xrange(self.rounds):
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-            if a == 1:
-                if b == 2:
-                    if c != 3:
-                        c = 3
-                        b = 3
-                    else:
-                        c = 2
-                elif b == 3:
-                    b = 2
-                    a = 2
-            elif a == 2:
-                a = 3
-            else:
-                a = 1
-
-    def calibrate(self):
-
-        a,b,c = 1,2,3
-        for i in xrange(self.rounds):
-            pass
-
-class NestedForLoops(Test):
-
-    version = 2.0
-    operations = 1000*10*5
-    rounds = 300
-
-    def test(self):
-
-        l1 = range(1000)
-        l2 = range(10)
-        l3 = range(5)
-        for i in xrange(self.rounds):
-            for i in l1:
-                for j in l2:
-                    for k in l3:
-                        pass
-
-    def calibrate(self):
-
-        l1 = range(1000)
-        l2 = range(10)
-        l3 = range(5)
-        for i in xrange(self.rounds):
-            pass
-
-class ForLoops(Test):
-
-    version = 2.0
-    operations = 5 * 5
-    rounds = 10000
-
-    def test(self):
-
-        l1 = range(100)
-        for i in xrange(self.rounds):
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-            for i in l1:
-                pass
-
-    def calibrate(self):
-
-        l1 = range(1000)
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Dict.py b/Tools/pybench/pybench-2.0/Dict.py
deleted file mode 100644
index 9cdd682..0000000
--- a/Tools/pybench/pybench-2.0/Dict.py
+++ /dev/null
@@ -1,504 +0,0 @@
-from pybench import Test
-
-class DictCreation(Test):
-
-    version = 2.0
-    operations = 5*(5 + 5)
-    rounds = 80000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            d1 = {}
-            d2 = {}
-            d3 = {}
-            d4 = {}
-            d5 = {}
-
-            d1 = {1:2,3:4,5:6}
-            d2 = {2:3,4:5,6:7}
-            d3 = {3:4,5:6,7:8}
-            d4 = {4:5,6:7,8:9}
-            d5 = {6:7,8:9,10:11}
-
-            d1 = {}
-            d2 = {}
-            d3 = {}
-            d4 = {}
-            d5 = {}
-
-            d1 = {1:2,3:4,5:6}
-            d2 = {2:3,4:5,6:7}
-            d3 = {3:4,5:6,7:8}
-            d4 = {4:5,6:7,8:9}
-            d5 = {6:7,8:9,10:11}
-
-            d1 = {}
-            d2 = {}
-            d3 = {}
-            d4 = {}
-            d5 = {}
-
-            d1 = {1:2,3:4,5:6}
-            d2 = {2:3,4:5,6:7}
-            d3 = {3:4,5:6,7:8}
-            d4 = {4:5,6:7,8:9}
-            d5 = {6:7,8:9,10:11}
-
-            d1 = {}
-            d2 = {}
-            d3 = {}
-            d4 = {}
-            d5 = {}
-
-            d1 = {1:2,3:4,5:6}
-            d2 = {2:3,4:5,6:7}
-            d3 = {3:4,5:6,7:8}
-            d4 = {4:5,6:7,8:9}
-            d5 = {6:7,8:9,10:11}
-
-            d1 = {}
-            d2 = {}
-            d3 = {}
-            d4 = {}
-            d5 = {}
-
-            d1 = {1:2,3:4,5:6}
-            d2 = {2:3,4:5,6:7}
-            d3 = {3:4,5:6,7:8}
-            d4 = {4:5,6:7,8:9}
-            d5 = {6:7,8:9,10:11}
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-class DictWithStringKeys(Test):
-
-    version = 2.0
-    operations = 5*(6 + 6)
-    rounds = 200000
-
-    def test(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-
-            d['abc'] = 1
-            d['def'] = 2
-            d['ghi'] = 3
-            d['jkl'] = 4
-            d['mno'] = 5
-            d['pqr'] = 6
-
-            d['abc']
-            d['def']
-            d['ghi']
-            d['jkl']
-            d['mno']
-            d['pqr']
-
-            d['abc'] = 1
-            d['def'] = 2
-            d['ghi'] = 3
-            d['jkl'] = 4
-            d['mno'] = 5
-            d['pqr'] = 6
-
-            d['abc']
-            d['def']
-            d['ghi']
-            d['jkl']
-            d['mno']
-            d['pqr']
-
-            d['abc'] = 1
-            d['def'] = 2
-            d['ghi'] = 3
-            d['jkl'] = 4
-            d['mno'] = 5
-            d['pqr'] = 6
-
-            d['abc']
-            d['def']
-            d['ghi']
-            d['jkl']
-            d['mno']
-            d['pqr']
-
-            d['abc'] = 1
-            d['def'] = 2
-            d['ghi'] = 3
-            d['jkl'] = 4
-            d['mno'] = 5
-            d['pqr'] = 6
-
-            d['abc']
-            d['def']
-            d['ghi']
-            d['jkl']
-            d['mno']
-            d['pqr']
-
-            d['abc'] = 1
-            d['def'] = 2
-            d['ghi'] = 3
-            d['jkl'] = 4
-            d['mno'] = 5
-            d['pqr'] = 6
-
-            d['abc']
-            d['def']
-            d['ghi']
-            d['jkl']
-            d['mno']
-            d['pqr']
-
-    def calibrate(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-            pass
-
-class DictWithFloatKeys(Test):
-
-    version = 2.0
-    operations = 5*(6 + 6)
-    rounds = 150000
-
-    def test(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-
-            d[1.234] = 1
-            d[2.345] = 2
-            d[3.456] = 3
-            d[4.567] = 4
-            d[5.678] = 5
-            d[6.789] = 6
-
-            d[1.234]
-            d[2.345]
-            d[3.456]
-            d[4.567]
-            d[5.678]
-            d[6.789]
-
-            d[1.234] = 1
-            d[2.345] = 2
-            d[3.456] = 3
-            d[4.567] = 4
-            d[5.678] = 5
-            d[6.789] = 6
-
-            d[1.234]
-            d[2.345]
-            d[3.456]
-            d[4.567]
-            d[5.678]
-            d[6.789]
-
-            d[1.234] = 1
-            d[2.345] = 2
-            d[3.456] = 3
-            d[4.567] = 4
-            d[5.678] = 5
-            d[6.789] = 6
-
-            d[1.234]
-            d[2.345]
-            d[3.456]
-            d[4.567]
-            d[5.678]
-            d[6.789]
-
-            d[1.234] = 1
-            d[2.345] = 2
-            d[3.456] = 3
-            d[4.567] = 4
-            d[5.678] = 5
-            d[6.789] = 6
-
-            d[1.234]
-            d[2.345]
-            d[3.456]
-            d[4.567]
-            d[5.678]
-            d[6.789]
-
-            d[1.234] = 1
-            d[2.345] = 2
-            d[3.456] = 3
-            d[4.567] = 4
-            d[5.678] = 5
-            d[6.789] = 6
-
-            d[1.234]
-            d[2.345]
-            d[3.456]
-            d[4.567]
-            d[5.678]
-            d[6.789]
-
-    def calibrate(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-            pass
-
-class DictWithIntegerKeys(Test):
-
-    version = 2.0
-    operations = 5*(6 + 6)
-    rounds = 200000
-
-    def test(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-
-            d[1] = 1
-            d[2] = 2
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-            d[6] = 6
-
-            d[1]
-            d[2]
-            d[3]
-            d[4]
-            d[5]
-            d[6]
-
-            d[1] = 1
-            d[2] = 2
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-            d[6] = 6
-
-            d[1]
-            d[2]
-            d[3]
-            d[4]
-            d[5]
-            d[6]
-
-            d[1] = 1
-            d[2] = 2
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-            d[6] = 6
-
-            d[1]
-            d[2]
-            d[3]
-            d[4]
-            d[5]
-            d[6]
-
-            d[1] = 1
-            d[2] = 2
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-            d[6] = 6
-
-            d[1]
-            d[2]
-            d[3]
-            d[4]
-            d[5]
-            d[6]
-
-            d[1] = 1
-            d[2] = 2
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-            d[6] = 6
-
-            d[1]
-            d[2]
-            d[3]
-            d[4]
-            d[5]
-            d[6]
-
-    def calibrate(self):
-
-        d = {}
-
-        for i in xrange(self.rounds):
-            pass
-
-class SimpleDictManipulation(Test):
-
-    version = 2.0
-    operations = 5*(6 + 6 + 6 + 6)
-    rounds = 100000
-
-    def test(self):
-
-        d = {}
-        has_key = d.has_key
-
-        for i in xrange(self.rounds):
-
-            d[0] = 3
-            d[1] = 4
-            d[2] = 5
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-
-            x = d[0]
-            x = d[1]
-            x = d[2]
-            x = d[3]
-            x = d[4]
-            x = d[5]
-
-            has_key(0)
-            has_key(2)
-            has_key(4)
-            has_key(6)
-            has_key(8)
-            has_key(10)
-
-            del d[0]
-            del d[1]
-            del d[2]
-            del d[3]
-            del d[4]
-            del d[5]
-
-            d[0] = 3
-            d[1] = 4
-            d[2] = 5
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-
-            x = d[0]
-            x = d[1]
-            x = d[2]
-            x = d[3]
-            x = d[4]
-            x = d[5]
-
-            has_key(0)
-            has_key(2)
-            has_key(4)
-            has_key(6)
-            has_key(8)
-            has_key(10)
-
-            del d[0]
-            del d[1]
-            del d[2]
-            del d[3]
-            del d[4]
-            del d[5]
-
-            d[0] = 3
-            d[1] = 4
-            d[2] = 5
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-
-            x = d[0]
-            x = d[1]
-            x = d[2]
-            x = d[3]
-            x = d[4]
-            x = d[5]
-
-            has_key(0)
-            has_key(2)
-            has_key(4)
-            has_key(6)
-            has_key(8)
-            has_key(10)
-
-            del d[0]
-            del d[1]
-            del d[2]
-            del d[3]
-            del d[4]
-            del d[5]
-
-            d[0] = 3
-            d[1] = 4
-            d[2] = 5
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-
-            x = d[0]
-            x = d[1]
-            x = d[2]
-            x = d[3]
-            x = d[4]
-            x = d[5]
-
-            has_key(0)
-            has_key(2)
-            has_key(4)
-            has_key(6)
-            has_key(8)
-            has_key(10)
-
-            del d[0]
-            del d[1]
-            del d[2]
-            del d[3]
-            del d[4]
-            del d[5]
-
-            d[0] = 3
-            d[1] = 4
-            d[2] = 5
-            d[3] = 3
-            d[4] = 4
-            d[5] = 5
-
-            x = d[0]
-            x = d[1]
-            x = d[2]
-            x = d[3]
-            x = d[4]
-            x = d[5]
-
-            has_key(0)
-            has_key(2)
-            has_key(4)
-            has_key(6)
-            has_key(8)
-            has_key(10)
-
-            del d[0]
-            del d[1]
-            del d[2]
-            del d[3]
-            del d[4]
-            del d[5]
-
-    def calibrate(self):
-
-        d = {}
-        has_key = d.has_key
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Exceptions.py b/Tools/pybench/pybench-2.0/Exceptions.py
deleted file mode 100644
index eff69c7..0000000
--- a/Tools/pybench/pybench-2.0/Exceptions.py
+++ /dev/null
@@ -1,699 +0,0 @@
-from pybench import Test
-
-class TryRaiseExcept(Test):
-
-    version = 2.0
-    operations = 2 + 3 + 3
-    rounds = 80000
-
-    def test(self):
-
-        error = ValueError
-
-        for i in xrange(self.rounds):
-            try:
-                raise error
-            except:
-                pass
-            try:
-                raise error
-            except:
-                pass
-            try:
-                raise error,"something"
-            except:
-                pass
-            try:
-                raise error,"something"
-            except:
-                pass
-            try:
-                raise error,"something"
-            except:
-                pass
-            try:
-                raise error("something")
-            except:
-                pass
-            try:
-                raise error("something")
-            except:
-                pass
-            try:
-                raise error("something")
-            except:
-                pass
-
-    def calibrate(self):
-
-        error = ValueError
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class TryExcept(Test):
-
-    version = 2.0
-    operations = 15 * 10
-    rounds = 150000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-            try:
-                pass
-            except:
-                pass
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-### Test to make Fredrik happy...
-
-if __name__ == '__main__':
-    import timeit
-    timeit.TestClass = TryRaiseExcept
-    timeit.main(['-s', 'test = TestClass(); test.rounds = 1000',
-                 'test.test()'])
diff --git a/Tools/pybench/pybench-2.0/Imports.py b/Tools/pybench/pybench-2.0/Imports.py
deleted file mode 100644
index afc728b..0000000
--- a/Tools/pybench/pybench-2.0/Imports.py
+++ /dev/null
@@ -1,138 +0,0 @@
-from pybench import Test
-
-# First imports:
-import os
-import package.submodule
-
-class SecondImport(Test):
-
-    version = 2.0
-    operations = 5 * 5
-    rounds = 40000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            import os
-            import os
-            import os
-            import os
-            import os
-
-            import os
-            import os
-            import os
-            import os
-            import os
-
-            import os
-            import os
-            import os
-            import os
-            import os
-
-            import os
-            import os
-            import os
-            import os
-            import os
-
-            import os
-            import os
-            import os
-            import os
-            import os
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class SecondPackageImport(Test):
-
-    version = 2.0
-    operations = 5 * 5
-    rounds = 40000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            import package
-            import package
-            import package
-            import package
-            import package
-
-            import package
-            import package
-            import package
-            import package
-            import package
-
-            import package
-            import package
-            import package
-            import package
-            import package
-
-            import package
-            import package
-            import package
-            import package
-            import package
-
-            import package
-            import package
-            import package
-            import package
-            import package
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-class SecondSubmoduleImport(Test):
-
-    version = 2.0
-    operations = 5 * 5
-    rounds = 40000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-            import package.submodule
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Instances.py b/Tools/pybench/pybench-2.0/Instances.py
deleted file mode 100644
index 1dfc82f..0000000
--- a/Tools/pybench/pybench-2.0/Instances.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from pybench import Test
-
-class CreateInstances(Test):
-
-    version = 2.0
-    operations = 3 + 7 + 4
-    rounds = 80000
-
-    def test(self):
-
-        class c:
-            pass
-
-        class d:
-            def __init__(self,a,b,c):
-                self.a = a
-                self.b = b
-                self.c = c
-
-        class e:
-            def __init__(self,a,b,c=4):
-                self.a = a
-                self.b = b
-                self.c = c
-                self.d = a
-                self.e = b
-                self.f = c
-
-        for i in xrange(self.rounds):
-            o = c()
-            o1 = c()
-            o2 = c()
-            p = d(i,i,3)
-            p1 = d(i,i,3)
-            p2 = d(i,3,3)
-            p3 = d(3,i,3)
-            p4 = d(i,i,i)
-            p5 = d(3,i,3)
-            p6 = d(i,i,i)
-            q = e(i,i,3)
-            q1 = e(i,i,3)
-            q2 = e(i,i,3)
-            q3 = e(i,i)
-
-    def calibrate(self):
-
-        class c:
-            pass
-
-        class d:
-            def __init__(self,a,b,c):
-                self.a = a
-                self.b = b
-                self.c = c
-
-        class e:
-            def __init__(self,a,b,c=4):
-                self.a = a
-                self.b = b
-                self.c = c
-                self.d = a
-                self.e = b
-                self.f = c
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/LICENSE b/Tools/pybench/pybench-2.0/LICENSE
deleted file mode 100644
index 17c6a6b..0000000
--- a/Tools/pybench/pybench-2.0/LICENSE
+++ /dev/null
@@ -1,25 +0,0 @@
-pybench License
----------------
-
-This copyright notice and license applies to all files in the pybench
-directory of the pybench distribution.
-
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-
-                   All Rights Reserved.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee or royalty is hereby
-granted, provided that the above copyright notice appear in all copies
-and that both that copyright notice and this permission notice appear
-in supporting documentation or portions thereof, including
-modifications, that you make.
-
-THE AUTHOR MARC-ANDRE LEMBURG DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
-INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
-FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
diff --git a/Tools/pybench/pybench-2.0/Lists.py b/Tools/pybench/pybench-2.0/Lists.py
deleted file mode 100644
index 67760db..0000000
--- a/Tools/pybench/pybench-2.0/Lists.py
+++ /dev/null
@@ -1,295 +0,0 @@
-from pybench import Test
-
-class SimpleListManipulation(Test):
-
-    version = 2.0
-    operations = 5* (6 + 6 + 6)
-    rounds = 130000
-
-    def test(self):
-
-        l = []
-        append = l.append
-
-        for i in xrange(self.rounds):
-
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            x = l[0]
-            x = l[1]
-            x = l[2]
-            x = l[3]
-            x = l[4]
-            x = l[5]
-
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            x = l[0]
-            x = l[1]
-            x = l[2]
-            x = l[3]
-            x = l[4]
-            x = l[5]
-
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            x = l[0]
-            x = l[1]
-            x = l[2]
-            x = l[3]
-            x = l[4]
-            x = l[5]
-
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            x = l[0]
-            x = l[1]
-            x = l[2]
-            x = l[3]
-            x = l[4]
-            x = l[5]
-
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            x = l[0]
-            x = l[1]
-            x = l[2]
-            x = l[3]
-            x = l[4]
-            x = l[5]
-
-            if len(l) > 10000:
-                # cut down the size
-                del l[:]
-
-    def calibrate(self):
-
-        l = []
-        append = l.append
-
-        for i in xrange(self.rounds):
-            pass
-
-class ListSlicing(Test):
-
-    version = 2.0
-    operations = 25*(3+1+2+1)
-    rounds = 800
-
-    def test(self):
-
-        n = range(100)
-        r = range(25)
-
-        for i in xrange(self.rounds):
-
-            l = n[:]
-
-            for j in r:
-
-                m = l[50:]
-                m = l[:25]
-                m = l[50:55]
-                l[:3] = n
-                m = l[:-1]
-                m = l[1:]
-                l[-1:] = n
-
-    def calibrate(self):
-
-        n = range(100)
-        r = range(25)
-
-        for i in xrange(self.rounds):
-            for j in r:
-                pass
-
-class SmallLists(Test):
-
-    version = 2.0
-    operations = 5*(1+ 6 + 6 + 3 + 1)
-    rounds = 80000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            l = []
-
-            append = l.append
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            l[:3] = [1,2,3]
-            m = l[:-1]
-            m = l[1:]
-
-            l[-1:] = [4,5,6]
-
-            l = []
-
-            append = l.append
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            l[:3] = [1,2,3]
-            m = l[:-1]
-            m = l[1:]
-
-            l[-1:] = [4,5,6]
-
-            l = []
-
-            append = l.append
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            l[:3] = [1,2,3]
-            m = l[:-1]
-            m = l[1:]
-
-            l[-1:] = [4,5,6]
-
-            l = []
-
-            append = l.append
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            l[:3] = [1,2,3]
-            m = l[:-1]
-            m = l[1:]
-
-            l[-1:] = [4,5,6]
-
-            l = []
-
-            append = l.append
-            append(2)
-            append(3)
-            append(4)
-            append(2)
-            append(3)
-            append(4)
-
-            l[0] = 3
-            l[1] = 4
-            l[2] = 5
-            l[3] = 3
-            l[4] = 4
-            l[5] = 5
-
-            l[:3] = [1,2,3]
-            m = l[:-1]
-            m = l[1:]
-
-            l[-1:] = [4,5,6]
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Lookups.py b/Tools/pybench/pybench-2.0/Lookups.py
deleted file mode 100644
index f20e7da..0000000
--- a/Tools/pybench/pybench-2.0/Lookups.py
+++ /dev/null
@@ -1,945 +0,0 @@
-from pybench import Test
-
-class SpecialClassAttribute(Test):
-
-    version = 2.0
-    operations = 5*(12 + 12)
-    rounds = 100000
-
-    def test(self):
-
-        class c:
-            pass
-
-        for i in xrange(self.rounds):
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            c.__a = 2
-            c.__b = 3
-            c.__c = 4
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-            x = c.__a
-            x = c.__b
-            x = c.__c
-
-    def calibrate(self):
-
-        class c:
-            pass
-
-        for i in xrange(self.rounds):
-            pass
-
-class NormalClassAttribute(Test):
-
-    version = 2.0
-    operations = 5*(12 + 12)
-    rounds = 100000
-
-    def test(self):
-
-        class c:
-            pass
-
-        for i in xrange(self.rounds):
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-            c.a = 2
-            c.b = 3
-            c.c = 4
-
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-            x = c.a
-            x = c.b
-            x = c.c
-
-    def calibrate(self):
-
-        class c:
-            pass
-
-        for i in xrange(self.rounds):
-            pass
-
-class SpecialInstanceAttribute(Test):
-
-    version = 2.0
-    operations = 5*(12 + 12)
-    rounds = 100000
-
-    def test(self):
-
-        class c:
-            pass
-        o = c()
-
-        for i in xrange(self.rounds):
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-            o.__a__ = 2
-            o.__b__ = 3
-            o.__c__ = 4
-
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-            x = o.__a__
-            x = o.__b__
-            x = o.__c__
-
-    def calibrate(self):
-
-        class c:
-            pass
-        o = c()
-
-        for i in xrange(self.rounds):
-            pass
-
-class NormalInstanceAttribute(Test):
-
-    version = 2.0
-    operations = 5*(12 + 12)
-    rounds = 100000
-
-    def test(self):
-
-        class c:
-            pass
-        o = c()
-
-        for i in xrange(self.rounds):
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-            o.a = 2
-            o.b = 3
-            o.c = 4
-
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-            x = o.a
-            x = o.b
-            x = o.c
-
-    def calibrate(self):
-
-        class c:
-            pass
-        o = c()
-
-        for i in xrange(self.rounds):
-            pass
-
-class BuiltinMethodLookup(Test):
-
-    version = 2.0
-    operations = 5*(3*5 + 3*5)
-    rounds = 70000
-
-    def test(self):
-
-        l = []
-        d = {}
-
-        for i in xrange(self.rounds):
-
-            l.append
-            l.append
-            l.append
-            l.append
-            l.append
-
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-
-            d.items
-            d.items
-            d.items
-            d.items
-            d.items
-
-            d.get
-            d.get
-            d.get
-            d.get
-            d.get
-
-            l.append
-            l.append
-            l.append
-            l.append
-            l.append
-
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-
-            d.items
-            d.items
-            d.items
-            d.items
-            d.items
-
-            d.get
-            d.get
-            d.get
-            d.get
-            d.get
-
-            l.append
-            l.append
-            l.append
-            l.append
-            l.append
-
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-
-            d.items
-            d.items
-            d.items
-            d.items
-            d.items
-
-            d.get
-            d.get
-            d.get
-            d.get
-            d.get
-
-            l.append
-            l.append
-            l.append
-            l.append
-            l.append
-
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-
-            d.items
-            d.items
-            d.items
-            d.items
-            d.items
-
-            d.get
-            d.get
-            d.get
-            d.get
-            d.get
-
-            l.append
-            l.append
-            l.append
-            l.append
-            l.append
-
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-            l.insert
-
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-            l.sort
-
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-            d.has_key
-
-            d.items
-            d.items
-            d.items
-            d.items
-            d.items
-
-            d.get
-            d.get
-            d.get
-            d.get
-            d.get
-
-    def calibrate(self):
-
-        l = []
-        d = {}
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/NewInstances.py b/Tools/pybench/pybench-2.0/NewInstances.py
deleted file mode 100644
index 258beba..0000000
--- a/Tools/pybench/pybench-2.0/NewInstances.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from pybench import Test
-
-# Check for new-style class support:
-try:
-    class c(object):
-        pass
-except NameError:
-    raise ImportError
-
-###
-
-class CreateNewInstances(Test):
-
-    version = 2.0
-    operations = 3 + 7 + 4
-    rounds = 60000
-
-    def test(self):
-
-        class c(object):
-            pass
-
-        class d(object):
-            def __init__(self,a,b,c):
-                self.a = a
-                self.b = b
-                self.c = c
-
-        class e(object):
-            def __init__(self,a,b,c=4):
-                self.a = a
-                self.b = b
-                self.c = c
-                self.d = a
-                self.e = b
-                self.f = c
-
-        for i in xrange(self.rounds):
-            o = c()
-            o1 = c()
-            o2 = c()
-            p = d(i,i,3)
-            p1 = d(i,i,3)
-            p2 = d(i,3,3)
-            p3 = d(3,i,3)
-            p4 = d(i,i,i)
-            p5 = d(3,i,3)
-            p6 = d(i,i,i)
-            q = e(i,i,3)
-            q1 = e(i,i,3)
-            q2 = e(i,i,3)
-            q3 = e(i,i)
-
-    def calibrate(self):
-
-        class c(object):
-            pass
-
-        class d(object):
-            def __init__(self,a,b,c):
-                self.a = a
-                self.b = b
-                self.c = c
-
-        class e(object):
-            def __init__(self,a,b,c=4):
-                self.a = a
-                self.b = b
-                self.c = c
-                self.d = a
-                self.e = b
-                self.f = c
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Numbers.py b/Tools/pybench/pybench-2.0/Numbers.py
deleted file mode 100644
index 10c8940..0000000
--- a/Tools/pybench/pybench-2.0/Numbers.py
+++ /dev/null
@@ -1,784 +0,0 @@
-from pybench import Test
-
-class CompareIntegers(Test):
-
-    version = 2.0
-    operations = 30 * 5
-    rounds = 120000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-            2 < 3
-            2 > 3
-            2 == 3
-            2 > 3
-            2 < 3
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareFloats(Test):
-
-    version = 2.0
-    operations = 30 * 5
-    rounds = 80000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-            2.1 < 3.31
-            2.1 > 3.31
-            2.1 == 3.31
-            2.1 > 3.31
-            2.1 < 3.31
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareFloatsIntegers(Test):
-
-    version = 2.0
-    operations = 30 * 5
-    rounds = 60000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-            2.1 < 4
-            2.1 > 4
-            2.1 == 4
-            2.1 > 4
-            2.1 < 4
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareLongs(Test):
-
-    version = 2.0
-    operations = 30 * 5
-    rounds = 70000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-            1234567890L < 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L == 3456789012345L
-            1234567890L > 3456789012345L
-            1234567890L < 3456789012345L
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/README b/Tools/pybench/pybench-2.0/README
deleted file mode 100644
index 022c8de..0000000
--- a/Tools/pybench/pybench-2.0/README
+++ /dev/null
@@ -1,368 +0,0 @@
-________________________________________________________________________
-
-PYBENCH - A Python Benchmark Suite
-________________________________________________________________________
-
-     Extendable suite of of low-level benchmarks for measuring
-          the performance of the Python implementation 
-                 (interpreter, compiler or VM).
-
-pybench is a collection of tests that provides a standardized way to
-measure the performance of Python implementations. It takes a very
-close look at different aspects of Python programs and let's you
-decide which factors are more important to you than others, rather
-than wrapping everything up in one number, like the other performance
-tests do (e.g. pystone which is included in the Python Standard
-Library).
-
-pybench has been used in the past by several Python developers to
-track down performance bottlenecks or to demonstrate the impact of
-optimizations and new features in Python.
-
-The command line interface for pybench is the file pybench.py. Run
-this script with option '--help' to get a listing of the possible
-options. Without options, pybench will simply execute the benchmark
-and then print out a report to stdout.
-
-
-Micro-Manual
-------------
-
-Run 'pybench.py -h' to see the help screen.  Run 'pybench.py' to run
-the benchmark suite using default settings and 'pybench.py -f <file>'
-to have it store the results in a file too.
-
-It is usually a good idea to run pybench.py multiple times to see
-whether the environment, timers and benchmark run-times are suitable
-for doing benchmark tests. 
-
-You can use the comparison feature of pybench.py ('pybench.py -c
-<file>') to check how well the system behaves in comparison to a
-reference run. 
-
-If the differences are well below 10% for each test, then you have a
-system that is good for doing benchmark testings.  Of you get random
-differences of more than 10% or significant differences between the
-values for minimum and average time, then you likely have some
-background processes running which cause the readings to become
-inconsistent. Examples include: web-browsers, email clients, RSS
-readers, music players, backup programs, etc.
-
-If you are only interested in a few tests of the whole suite, you can
-use the filtering option, e.g. 'pybench.py -t string' will only
-run/show the tests that have 'string' in their name.
-
-This is the current output of pybench.py --help:
-
-"""
-------------------------------------------------------------------------
-PYBENCH - a benchmark test suite for Python interpreters/compilers.
-------------------------------------------------------------------------
-
-Synopsis:
- pybench.py [option] files...
-
-Options and default settings:
-  -n arg           number of rounds (10)
-  -f arg           save benchmark to file arg ()
-  -c arg           compare benchmark with the one in file arg ()
-  -s arg           show benchmark in file arg, then exit ()
-  -w arg           set warp factor to arg (10)
-  -t arg           run only tests with names matching arg ()
-  -C arg           set the number of calibration runs to arg (20)
-  -d               hide noise in comparisons (0)
-  -v               verbose output (not recommended) (0)
-  --with-gc        enable garbage collection (0)
-  --with-syscheck  use default sys check interval (0)
-  --timer arg      use given timer (time.time)
-  -h               show this help text
-  --help           show this help text
-  --debug          enable debugging
-  --copyright      show copyright
-  --examples       show examples of usage
-
-Version:
- 2.0
-
-The normal operation is to run the suite and display the
-results. Use -f to save them for later reuse or comparisons.
-
-Available timers:
-
-   time.time
-   time.clock
-   systimes.processtime
-
-Examples:
-
-python2.1 pybench.py -f p21.pybench
-python2.5 pybench.py -f p25.pybench
-python pybench.py -s p25.pybench -c p21.pybench
-"""
-
-License
--------
-
-See LICENSE file.
-
-
-Sample output
--------------
-
-"""
--------------------------------------------------------------------------------
-PYBENCH 2.0
--------------------------------------------------------------------------------
-* using Python 2.4.2
-* disabled garbage collection
-* system check interval set to maximum: 2147483647
-* using timer: time.time
-
-Calibrating tests. Please wait...
-
-Running 10 round(s) of the suite at warp factor 10:
-
-* Round 1 done in 6.388 seconds.
-* Round 2 done in 6.485 seconds.
-* Round 3 done in 6.786 seconds.
-...
-* Round 10 done in 6.546 seconds.
-
--------------------------------------------------------------------------------
-Benchmark: 2006-06-12 12:09:25
--------------------------------------------------------------------------------
-
-    Rounds: 10
-    Warp:   10
-    Timer:  time.time
-
-    Machine Details:
-       Platform ID:  Linux-2.6.8-24.19-default-x86_64-with-SuSE-9.2-x86-64
-       Processor:    x86_64
-
-    Python:
-       Executable:   /usr/local/bin/python
-       Version:      2.4.2
-       Compiler:     GCC 3.3.4 (pre 3.3.5 20040809)
-       Bits:         64bit
-       Build:        Oct  1 2005 15:24:35 (#1)
-       Unicode:      UCS2
-
-
-Test                             minimum  average  operation  overhead
--------------------------------------------------------------------------------
-          BuiltinFunctionCalls:    126ms    145ms    0.28us    0.274ms
-           BuiltinMethodLookup:    124ms    130ms    0.12us    0.316ms
-                 CompareFloats:    109ms    110ms    0.09us    0.361ms
-         CompareFloatsIntegers:    100ms    104ms    0.12us    0.271ms
-               CompareIntegers:    137ms    138ms    0.08us    0.542ms
-        CompareInternedStrings:    124ms    127ms    0.08us    1.367ms
-                  CompareLongs:    100ms    104ms    0.10us    0.316ms
-                CompareStrings:    111ms    115ms    0.12us    0.929ms
-                CompareUnicode:    108ms    128ms    0.17us    0.693ms
-                 ConcatStrings:    142ms    155ms    0.31us    0.562ms
-                 ConcatUnicode:    119ms    127ms    0.42us    0.384ms
-               CreateInstances:    123ms    128ms    1.14us    0.367ms
-            CreateNewInstances:    121ms    126ms    1.49us    0.335ms
-       CreateStringsWithConcat:    130ms    135ms    0.14us    0.916ms
-       CreateUnicodeWithConcat:    130ms    135ms    0.34us    0.361ms
-                  DictCreation:    108ms    109ms    0.27us    0.361ms
-             DictWithFloatKeys:    149ms    153ms    0.17us    0.678ms
-           DictWithIntegerKeys:    124ms    126ms    0.11us    0.915ms
-            DictWithStringKeys:    114ms    117ms    0.10us    0.905ms
-                      ForLoops:    110ms    111ms    4.46us    0.063ms
-                    IfThenElse:    118ms    119ms    0.09us    0.685ms
-                   ListSlicing:    116ms    120ms    8.59us    0.103ms
-                NestedForLoops:    125ms    137ms    0.09us    0.019ms
-          NormalClassAttribute:    124ms    136ms    0.11us    0.457ms
-       NormalInstanceAttribute:    110ms    117ms    0.10us    0.454ms
-           PythonFunctionCalls:    107ms    113ms    0.34us    0.271ms
-             PythonMethodCalls:    140ms    149ms    0.66us    0.141ms
-                     Recursion:    156ms    166ms    3.32us    0.452ms
-                  SecondImport:    112ms    118ms    1.18us    0.180ms
-           SecondPackageImport:    118ms    127ms    1.27us    0.180ms
-         SecondSubmoduleImport:    140ms    151ms    1.51us    0.180ms
-       SimpleComplexArithmetic:    128ms    139ms    0.16us    0.361ms
-        SimpleDictManipulation:    134ms    136ms    0.11us    0.452ms
-         SimpleFloatArithmetic:    110ms    113ms    0.09us    0.571ms
-      SimpleIntFloatArithmetic:    106ms    111ms    0.08us    0.548ms
-       SimpleIntegerArithmetic:    106ms    109ms    0.08us    0.544ms
-        SimpleListManipulation:    103ms    113ms    0.10us    0.587ms
-          SimpleLongArithmetic:    112ms    118ms    0.18us    0.271ms
-                    SmallLists:    105ms    116ms    0.17us    0.366ms
-                   SmallTuples:    108ms    128ms    0.24us    0.406ms
-         SpecialClassAttribute:    119ms    136ms    0.11us    0.453ms
-      SpecialInstanceAttribute:    143ms    155ms    0.13us    0.454ms
-                StringMappings:    115ms    121ms    0.48us    0.405ms
-              StringPredicates:    120ms    129ms    0.18us    2.064ms
-                 StringSlicing:    111ms    127ms    0.23us    0.781ms
-                     TryExcept:    125ms    126ms    0.06us    0.681ms
-                TryRaiseExcept:    133ms    137ms    2.14us    0.361ms
-                  TupleSlicing:    117ms    120ms    0.46us    0.066ms
-               UnicodeMappings:    156ms    160ms    4.44us    0.429ms
-             UnicodePredicates:    117ms    121ms    0.22us    2.487ms
-             UnicodeProperties:    115ms    153ms    0.38us    2.070ms
-                UnicodeSlicing:    126ms    129ms    0.26us    0.689ms
--------------------------------------------------------------------------------
-Totals:                           6283ms   6673ms
-"""
-________________________________________________________________________
-
-Writing New Tests
-________________________________________________________________________
-
-pybench tests are simple modules defining one or more pybench.Test
-subclasses.
-
-Writing a test essentially boils down to providing two methods:
-.test() which runs .rounds number of .operations test operations each
-and .calibrate() which does the same except that it doesn't actually
-execute the operations.
-
-
-Here's an example:
-------------------
-
-from pybench import Test
-
-class IntegerCounting(Test):
-
-    # Version number of the test as float (x.yy); this is important
-    # for comparisons of benchmark runs - tests with unequal version
-    # number will not get compared.
-    version = 1.0
-    
-    # The number of abstract operations done in each round of the
-    # test. An operation is the basic unit of what you want to
-    # measure. The benchmark will output the amount of run-time per
-    # operation. Note that in order to raise the measured timings
-    # significantly above noise level, it is often required to repeat
-    # sets of operations more than once per test round. The measured
-    # overhead per test round should be less than 1 second.
-    operations = 20
-
-    # Number of rounds to execute per test run. This should be
-    # adjusted to a figure that results in a test run-time of between
-    # 1-2 seconds (at warp 1).
-    rounds = 100000
-
-    def test(self):
-
-	""" Run the test.
-
-	    The test needs to run self.rounds executing
-	    self.operations number of operations each.
-
-        """
-        # Init the test
-        a = 1
-
-        # Run test rounds
-	#
-        # NOTE: Use xrange() for all test loops unless you want to face
-	# a 20MB process !
-	#
-        for i in xrange(self.rounds):
-
-            # Repeat the operations per round to raise the run-time
-            # per operation significantly above the noise level of the
-            # for-loop overhead. 
-
-	    # Execute 20 operations (a += 1):
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-            a += 1
-
-    def calibrate(self):
-
-	""" Calibrate the test.
-
-	    This method should execute everything that is needed to
-	    setup and run the test - except for the actual operations
-	    that you intend to measure. pybench uses this method to
-            measure the test implementation overhead.
-
-        """
-        # Init the test
-        a = 1
-
-        # Run test rounds (without actually doing any operation)
-        for i in xrange(self.rounds):
-
-	    # Skip the actual execution of the operations, since we
-	    # only want to measure the test's administration overhead.
-            pass
-
-Registering a new test module
------------------------------
-
-To register a test module with pybench, the classes need to be
-imported into the pybench.Setup module. pybench will then scan all the
-symbols defined in that module for subclasses of pybench.Test and
-automatically add them to the benchmark suite.
-
-
-Breaking Comparability
-----------------------
-
-If a change is made to any individual test that means it is no
-longer strictly comparable with previous runs, the '.version' class
-variable should be updated. Therefafter, comparisons with previous
-versions of the test will list as "n/a" to reflect the change.
-
-
-Version History
----------------
-
-  2.0: rewrote parts of pybench which resulted in more repeatable
-       timings:
-        - made timer a parameter
-        - changed the platform default timer to use high-resolution
-          timers rather than process timers (which have a much lower
-          resolution)
-        - added option to select timer
-        - added process time timer (using systimes.py)
-        - changed to use min() as timing estimator (average
-          is still taken as well to provide an idea of the difference)
-        - garbage collection is turned off per default
-        - sys check interval is set to the highest possible value
-        - calibration is now a separate step and done using
-          a different strategy that allows measuring the test
-          overhead more accurately
-        - modified the tests to each give a run-time of between
-          100-200ms using warp 10
-        - changed default warp factor to 10 (from 20)
-        - compared results with timeit.py and confirmed measurements
-        - bumped all test versions to 2.0
-        - updated platform.py to the latest version
-        - changed the output format a bit to make it look
-          nicer
-        - refactored the APIs somewhat
-  1.3+: Steve Holden added the NewInstances test and the filtering 
-       option during the NeedForSpeed sprint; this also triggered a long 
-       discussion on how to improve benchmark timing and finally
-       resulted in the release of 2.0
-  1.3: initial checkin into the Python SVN repository
-
-
-Have fun,
---
-Marc-Andre Lemburg
-mal@lemburg.com
diff --git a/Tools/pybench/pybench-2.0/Setup.py b/Tools/pybench/pybench-2.0/Setup.py
deleted file mode 100644
index f1417e6..0000000
--- a/Tools/pybench/pybench-2.0/Setup.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#!python
-
-# Setup file for pybench
-#
-# This file has to import all tests to be run; it is executed as
-# Python source file, so you can do all kinds of manipulations here
-# rather than having to edit the tests themselves.
-#
-# Note: Please keep this module compatible to Python 1.5.2.
-#
-# Tests may include features in later Python versions, but these
-# should then be embedded in try-except clauses in this configuration
-# module.
-
-# Defaults
-Number_of_rounds = 10
-Warp_factor = 10
-
-# Import tests
-from Arithmetic import *
-from Calls import *
-from Constructs import *
-from Lookups import *
-from Instances import *
-try:
-    from NewInstances import *
-except ImportError:
-    pass
-from Lists import *
-from Tuples import *
-from Dict import *
-from Exceptions import *
-from Imports import *
-from Strings import *
-from Numbers import *
-try:
-    from Unicode import *
-except (ImportError, SyntaxError):
-    pass
diff --git a/Tools/pybench/pybench-2.0/Strings.py b/Tools/pybench/pybench-2.0/Strings.py
deleted file mode 100644
index 3be8b35..0000000
--- a/Tools/pybench/pybench-2.0/Strings.py
+++ /dev/null
@@ -1,562 +0,0 @@
-from pybench import Test
-from string import join
-
-class ConcatStrings(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 100000
-
-    def test(self):
-
-        # Make sure the strings are *not* interned
-        s = join(map(str,range(100)))
-        t = join(map(str,range(1,101)))
-
-        for i in xrange(self.rounds):
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-    def calibrate(self):
-
-        s = join(map(str,range(100)))
-        t = join(map(str,range(1,101)))
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareStrings(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 200000
-
-    def test(self):
-
-        # Make sure the strings are *not* interned
-        s = join(map(str,range(10)))
-        t = join(map(str,range(10))) + "abc"
-
-        for i in xrange(self.rounds):
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-    def calibrate(self):
-
-        s = join(map(str,range(10)))
-        t = join(map(str,range(10))) + "abc"
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareInternedStrings(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 300000
-
-    def test(self):
-
-        # Make sure the strings *are* interned
-        s = intern(join(map(str,range(10))))
-        t = s
-
-        for i in xrange(self.rounds):
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-            t == s
-            t == s
-            t >= s
-            t > s
-            t < s
-
-    def calibrate(self):
-
-        s = intern(join(map(str,range(10))))
-        t = s
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CreateStringsWithConcat(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 200000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            s = 'om'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-            s = s + 'xax'
-            s = s + 'xbx'
-            s = s + 'xcx'
-            s = s + 'xdx'
-            s = s + 'xex'
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class StringSlicing(Test):
-
-    version = 2.0
-    operations = 5 * 7
-    rounds = 160000
-
-    def test(self):
-
-        s = join(map(str,range(100)))
-
-        for i in xrange(self.rounds):
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-    def calibrate(self):
-
-        s = join(map(str,range(100)))
-
-        for i in xrange(self.rounds):
-            pass
-
-### String methods
-
-if hasattr('', 'lower'):
-
-    class StringMappings(Test):
-
-        version = 2.0
-        operations = 3 * (5 + 4 + 2 + 1)
-        rounds = 70000
-
-        def test(self):
-
-            s = join(map(chr,range(20)),'')
-            t = join(map(chr,range(50)),'')
-            u = join(map(chr,range(100)),'')
-            v = join(map(chr,range(256)),'')
-
-            for i in xrange(self.rounds):
-
-                s.lower()
-                s.lower()
-                s.lower()
-                s.lower()
-                s.lower()
-
-                s.upper()
-                s.upper()
-                s.upper()
-                s.upper()
-                s.upper()
-
-                s.title()
-                s.title()
-                s.title()
-                s.title()
-                s.title()
-
-                t.lower()
-                t.lower()
-                t.lower()
-                t.lower()
-
-                t.upper()
-                t.upper()
-                t.upper()
-                t.upper()
-
-                t.title()
-                t.title()
-                t.title()
-                t.title()
-
-                u.lower()
-                u.lower()
-
-                u.upper()
-                u.upper()
-
-                u.title()
-                u.title()
-
-                v.lower()
-
-                v.upper()
-
-                v.title()
-
-        def calibrate(self):
-
-            s = join(map(chr,range(20)),'')
-            t = join(map(chr,range(50)),'')
-            u = join(map(chr,range(100)),'')
-            v = join(map(chr,range(256)),'')
-
-            for i in xrange(self.rounds):
-                pass
-
-    class StringPredicates(Test):
-
-        version = 2.0
-        operations = 10 * 7
-        rounds = 100000
-
-        def test(self):
-
-            data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
-            len_data = len(data)
-
-            for i in xrange(self.rounds):
-                s = data[i % len_data]
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-                s.isalnum()
-                s.isalpha()
-                s.isdigit()
-                s.islower()
-                s.isspace()
-                s.istitle()
-                s.isupper()
-
-        def calibrate(self):
-
-            data = ('abc', '123', '   ', '\u1234\u2345\u3456', '\uFFFF'*10)
-            data = ('abc', '123', '   ', '\xe4\xf6\xfc', '\xdf'*10)
-            len_data = len(data)
-
-            for i in xrange(self.rounds):
-                s = data[i % len_data]
diff --git a/Tools/pybench/pybench-2.0/Tuples.py b/Tools/pybench/pybench-2.0/Tuples.py
deleted file mode 100644
index 8e46989..0000000
--- a/Tools/pybench/pybench-2.0/Tuples.py
+++ /dev/null
@@ -1,360 +0,0 @@
-from pybench import Test
-
-class TupleSlicing(Test):
-
-    version = 2.0
-    operations = 3 * 25 * 10 * 7
-    rounds = 500
-
-    def test(self):
-
-        r = range(25)
-        t = tuple(range(100))
-
-        for i in xrange(self.rounds):
-
-            for j in r:
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-                m = t[50:]
-                m = t[:25]
-                m = t[50:55]
-                m = t[:-1]
-                m = t[1:]
-                m = t[-10:]
-                m = t[:10]
-
-    def calibrate(self):
-
-        r = range(25)
-        t = tuple(range(100))
-
-        for i in xrange(self.rounds):
-            for j in r:
-                pass
-
-class SmallTuples(Test):
-
-    version = 2.0
-    operations = 5*(1 + 3 + 6 + 2)
-    rounds = 90000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-
-            t = (1,2,3,4,5,6)
-
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-
-            l = list(t)
-            t = tuple(l)
-
-            t = (1,2,3,4,5,6)
-
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-
-            l = list(t)
-            t = tuple(l)
-
-            t = (1,2,3,4,5,6)
-
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-
-            l = list(t)
-            t = tuple(l)
-
-            t = (1,2,3,4,5,6)
-
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-
-            l = list(t)
-            t = tuple(l)
-
-            t = (1,2,3,4,5,6)
-
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-            a,b,c,d,e,f = t
-
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-            a,b,c = t[:3]
-
-            l = list(t)
-            t = tuple(l)
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
diff --git a/Tools/pybench/pybench-2.0/Unicode.py b/Tools/pybench/pybench-2.0/Unicode.py
deleted file mode 100644
index 153a91e..0000000
--- a/Tools/pybench/pybench-2.0/Unicode.py
+++ /dev/null
@@ -1,542 +0,0 @@
-try:
-    unicode
-except NameError:
-    raise ImportError
-
-from pybench import Test
-from string import join
-
-class ConcatUnicode(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 60000
-
-    def test(self):
-
-        # Make sure the strings are *not* interned
-        s = unicode(join(map(str,range(100))))
-        t = unicode(join(map(str,range(1,101))))
-
-        for i in xrange(self.rounds):
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-            t + s
-            t + s
-            t + s
-            t + s
-            t + s
-
-    def calibrate(self):
-
-        s = unicode(join(map(str,range(100))))
-        t = unicode(join(map(str,range(1,101))))
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CompareUnicode(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 150000
-
-    def test(self):
-
-        # Make sure the strings are *not* interned
-        s = unicode(join(map(str,range(10))))
-        t = unicode(join(map(str,range(10))) + "abc")
-
-        for i in xrange(self.rounds):
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-            t < s
-            t > s
-            t == s
-            t > s
-            t < s
-
-    def calibrate(self):
-
-        s = unicode(join(map(str,range(10))))
-        t = unicode(join(map(str,range(10))) + "abc")
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class CreateUnicodeWithConcat(Test):
-
-    version = 2.0
-    operations = 10 * 5
-    rounds = 80000
-
-    def test(self):
-
-        for i in xrange(self.rounds):
-            s = u'om'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-            s = s + u'xax'
-            s = s + u'xbx'
-            s = s + u'xcx'
-            s = s + u'xdx'
-            s = s + u'xex'
-
-    def calibrate(self):
-
-        for i in xrange(self.rounds):
-            pass
-
-
-class UnicodeSlicing(Test):
-
-    version = 2.0
-    operations = 5 * 7
-    rounds = 140000
-
-    def test(self):
-
-        s = unicode(join(map(str,range(100))))
-
-        for i in xrange(self.rounds):
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-            s[50:]
-            s[:25]
-            s[50:55]
-            s[-1:]
-            s[:1]
-            s[2:]
-            s[11:-11]
-
-    def calibrate(self):
-
-        s = unicode(join(map(str,range(100))))
-
-        for i in xrange(self.rounds):
-            pass
-
-### String methods
-
-class UnicodeMappings(Test):
-
-    version = 2.0
-    operations = 3 * (5 + 4 + 2 + 1)
-    rounds = 10000
-
-    def test(self):
-
-        s = join(map(unichr,range(20)),'')
-        t = join(map(unichr,range(100)),'')
-        u = join(map(unichr,range(500)),'')
-        v = join(map(unichr,range(1000)),'')
-
-        for i in xrange(self.rounds):
-
-            s.lower()
-            s.lower()
-            s.lower()
-            s.lower()
-            s.lower()
-
-            s.upper()
-            s.upper()
-            s.upper()
-            s.upper()
-            s.upper()
-
-            s.title()
-            s.title()
-            s.title()
-            s.title()
-            s.title()
-
-            t.lower()
-            t.lower()
-            t.lower()
-            t.lower()
-
-            t.upper()
-            t.upper()
-            t.upper()
-            t.upper()
-
-            t.title()
-            t.title()
-            t.title()
-            t.title()
-
-            u.lower()
-            u.lower()
-
-            u.upper()
-            u.upper()
-
-            u.title()
-            u.title()
-
-            v.lower()
-
-            v.upper()
-
-            v.title()
-
-    def calibrate(self):
-
-        s = join(map(unichr,range(20)),'')
-        t = join(map(unichr,range(100)),'')
-        u = join(map(unichr,range(500)),'')
-        v = join(map(unichr,range(1000)),'')
-
-        for i in xrange(self.rounds):
-            pass
-
-class UnicodePredicates(Test):
-
-    version = 2.0
-    operations = 5 * 9
-    rounds = 120000
-
-    def test(self):
-
-        data = (u'abc', u'123', u'   ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
-        len_data = len(data)
-
-        for i in xrange(self.rounds):
-            s = data[i % len_data]
-
-            s.isalnum()
-            s.isalpha()
-            s.isdecimal()
-            s.isdigit()
-            s.islower()
-            s.isnumeric()
-            s.isspace()
-            s.istitle()
-            s.isupper()
-
-            s.isalnum()
-            s.isalpha()
-            s.isdecimal()
-            s.isdigit()
-            s.islower()
-            s.isnumeric()
-            s.isspace()
-            s.istitle()
-            s.isupper()
-
-            s.isalnum()
-            s.isalpha()
-            s.isdecimal()
-            s.isdigit()
-            s.islower()
-            s.isnumeric()
-            s.isspace()
-            s.istitle()
-            s.isupper()
-
-            s.isalnum()
-            s.isalpha()
-            s.isdecimal()
-            s.isdigit()
-            s.islower()
-            s.isnumeric()
-            s.isspace()
-            s.istitle()
-            s.isupper()
-
-            s.isalnum()
-            s.isalpha()
-            s.isdecimal()
-            s.isdigit()
-            s.islower()
-            s.isnumeric()
-            s.isspace()
-            s.istitle()
-            s.isupper()
-
-    def calibrate(self):
-
-        data = (u'abc', u'123', u'   ', u'\u1234\u2345\u3456', u'\uFFFF'*10)
-        len_data = len(data)
-
-        for i in xrange(self.rounds):
-            s = data[i % len_data]
-
-try:
-    import unicodedata
-except ImportError:
-    pass
-else:
-    class UnicodeProperties(Test):
-
-        version = 2.0
-        operations = 5 * 8
-        rounds = 100000
-
-        def test(self):
-
-            data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF')
-            len_data = len(data)
-            digit = unicodedata.digit
-            numeric = unicodedata.numeric
-            decimal = unicodedata.decimal
-            category = unicodedata.category
-            bidirectional = unicodedata.bidirectional
-            decomposition = unicodedata.decomposition
-            mirrored = unicodedata.mirrored
-            combining = unicodedata.combining
-
-            for i in xrange(self.rounds):
-
-                c = data[i % len_data]
-
-                digit(c, None)
-                numeric(c, None)
-                decimal(c, None)
-                category(c)
-                bidirectional(c)
-                decomposition(c)
-                mirrored(c)
-                combining(c)
-
-                digit(c, None)
-                numeric(c, None)
-                decimal(c, None)
-                category(c)
-                bidirectional(c)
-                decomposition(c)
-                mirrored(c)
-                combining(c)
-
-                digit(c, None)
-                numeric(c, None)
-                decimal(c, None)
-                category(c)
-                bidirectional(c)
-                decomposition(c)
-                mirrored(c)
-                combining(c)
-
-                digit(c, None)
-                numeric(c, None)
-                decimal(c, None)
-                category(c)
-                bidirectional(c)
-                decomposition(c)
-                mirrored(c)
-                combining(c)
-
-                digit(c, None)
-                numeric(c, None)
-                decimal(c, None)
-                category(c)
-                bidirectional(c)
-                decomposition(c)
-                mirrored(c)
-                combining(c)
-
-        def calibrate(self):
-
-            data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF')
-            len_data = len(data)
-            digit = unicodedata.digit
-            numeric = unicodedata.numeric
-            decimal = unicodedata.decimal
-            category = unicodedata.category
-            bidirectional = unicodedata.bidirectional
-            decomposition = unicodedata.decomposition
-            mirrored = unicodedata.mirrored
-            combining = unicodedata.combining
-
-            for i in xrange(self.rounds):
-
-                c = data[i % len_data]
diff --git a/Tools/pybench/pybench-2.0/clockres.py b/Tools/pybench/pybench-2.0/clockres.py
deleted file mode 100644
index a7855f2..0000000
--- a/Tools/pybench/pybench-2.0/clockres.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-
-""" clockres - calculates the resolution in seconds of a given timer.
-
-    Copyright (c) 2006, Marc-Andre Lemburg (mal@egenix.com). See the
-    documentation for further information on copyrights, or contact
-    the author. All Rights Reserved.
-
-"""
-import time
-
-TEST_TIME = 1.0
-
-def clockres(timer):
-    d = {}
-    wallclock = time.time
-    start = wallclock()
-    stop = wallclock() + TEST_TIME
-    spin_loops = range(1000)
-    while 1:
-        now = wallclock()
-        if now >= stop:
-           break
-        for i in spin_loops:
-            d[timer()] = 1
-    values = d.keys()
-    values.sort()
-    min_diff = TEST_TIME
-    for i in range(len(values) - 1):
-        diff = values[i+1] - values[i]
-        if diff < min_diff:
-            min_diff = diff
-    return min_diff
-
-if __name__ == '__main__':
-    print 'Clock resolution of various timer implementations:'    
-    print 'time.clock:           %10.3fus' % (clockres(time.clock) * 1e6)
-    print 'time.time:            %10.3fus' % (clockres(time.time) * 1e6)
-    try:
-        import systimes
-        print 'systimes.processtime: %10.3fus' % (clockres(systimes.processtime) * 1e6)
-    except ImportError:
-        pass
-
diff --git a/Tools/pybench/pybench-2.0/package/__init__.py b/Tools/pybench/pybench-2.0/package/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/Tools/pybench/pybench-2.0/package/__init__.py
+++ /dev/null
diff --git a/Tools/pybench/pybench-2.0/package/submodule.py b/Tools/pybench/pybench-2.0/package/submodule.py
deleted file mode 100644
index e69de29..0000000
--- a/Tools/pybench/pybench-2.0/package/submodule.py
+++ /dev/null
diff --git a/Tools/pybench/pybench-2.0/platform.py b/Tools/pybench/pybench-2.0/platform.py
deleted file mode 100755
index 288bc95..0000000
--- a/Tools/pybench/pybench-2.0/platform.py
+++ /dev/null
@@ -1,1254 +0,0 @@
-#!/usr/bin/env python
-
-""" This module tries to retrieve as much platform-identifying data as
-    possible. It makes this information available via function APIs.
-
-    If called from the command line, it prints the platform
-    information concatenated as single string to stdout. The output
-    format is useable as part of a filename.
-
-"""
-#    This module is maintained by Marc-Andre Lemburg <mal@egenix.com>.
-#    If you find problems, please submit bug reports/patches via the
-#    Python SourceForge Project Page and assign them to "lemburg".
-#
-#    Note: Please keep this module compatible to Python 1.5.2.
-#
-#    Still needed:
-#    * more support for WinCE
-#    * support for MS-DOS (PythonDX ?)
-#    * support for Amiga and other still unsupported platforms running Python
-#    * support for additional Linux distributions
-#
-#    Many thanks to all those who helped adding platform-specific
-#    checks (in no particular order):
-#
-#      Charles G Waldman, David Arnold, Gordon McMillan, Ben Darnell,
-#      Jeff Bauer, Cliff Crawford, Ivan Van Laningham, Josef
-#      Betancourt, Randall Hopper, Karl Putland, John Farrell, Greg
-#      Andruk, Just van Rossum, Thomas Heller, Mark R. Levinson, Mark
-#      Hammond, Bill Tutt, Hans Nowak, Uwe Zessin (OpenVMS support),
-#      Colin Kong, Trent Mick, Guido van Rossum
-#
-#    History:
-#
-#    <see CVS and SVN checkin messages for history>
-#
-#    1.0.3 - added normalization of Windows system name
-#    1.0.2 - added more Windows support
-#    1.0.1 - reformatted to make doc.py happy
-#    1.0.0 - reformatted a bit and checked into Python CVS
-#    0.8.0 - added sys.version parser and various new access
-#            APIs (python_version(), python_compiler(), etc.)
-#    0.7.2 - fixed architecture() to use sizeof(pointer) where available
-#    0.7.1 - added support for Caldera OpenLinux
-#    0.7.0 - some fixes for WinCE; untabified the source file
-#    0.6.2 - support for OpenVMS - requires version 1.5.2-V006 or higher and
-#            vms_lib.getsyi() configured
-#    0.6.1 - added code to prevent 'uname -p' on platforms which are
-#            known not to support it
-#    0.6.0 - fixed win32_ver() to hopefully work on Win95,98,NT and Win2k;
-#            did some cleanup of the interfaces - some APIs have changed
-#    0.5.5 - fixed another type in the MacOS code... should have
-#            used more coffee today ;-)
-#    0.5.4 - fixed a few typos in the MacOS code
-#    0.5.3 - added experimental MacOS support; added better popen()
-#            workarounds in _syscmd_ver() -- still not 100% elegant
-#            though
-#    0.5.2 - fixed uname() to return '' instead of 'unknown' in all
-#            return values (the system uname command tends to return
-#            'unknown' instead of just leaving the field emtpy)
-#    0.5.1 - included code for slackware dist; added exception handlers
-#            to cover up situations where platforms don't have os.popen
-#            (e.g. Mac) or fail on socket.gethostname(); fixed libc
-#            detection RE
-#    0.5.0 - changed the API names referring to system commands to *syscmd*;
-#            added java_ver(); made syscmd_ver() a private
-#            API (was system_ver() in previous versions) -- use uname()
-#            instead; extended the win32_ver() to also return processor
-#            type information
-#    0.4.0 - added win32_ver() and modified the platform() output for WinXX
-#    0.3.4 - fixed a bug in _follow_symlinks()
-#    0.3.3 - fixed popen() and "file" command invokation bugs
-#    0.3.2 - added architecture() API and support for it in platform()
-#    0.3.1 - fixed syscmd_ver() RE to support Windows NT
-#    0.3.0 - added system alias support
-#    0.2.3 - removed 'wince' again... oh well.
-#    0.2.2 - added 'wince' to syscmd_ver() supported platforms
-#    0.2.1 - added cache logic and changed the platform string format
-#    0.2.0 - changed the API to use functions instead of module globals
-#            since some action take too long to be run on module import
-#    0.1.0 - first release
-#
-#    You can always get the latest version of this module at:
-#
-#             http://www.egenix.com/files/python/platform.py
-#
-#    If that URL should fail, try contacting the author.
-
-__copyright__ = """
-    Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com
-    Copyright (c) 2000-2003, eGenix.com Software GmbH; mailto:info@egenix.com
-
-    Permission to use, copy, modify, and distribute this software and its
-    documentation for any purpose and without fee or royalty is hereby granted,
-    provided that the above copyright notice appear in all copies and that
-    both that copyright notice and this permission notice appear in
-    supporting documentation or portions thereof, including modifications,
-    that you make.
-
-    EGENIX.COM SOFTWARE GMBH DISCLAIMS ALL WARRANTIES WITH REGARD TO
-    THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-    FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
-    INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
-    FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-    NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-    WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
-
-"""
-
-__version__ = '1.0.4'
-
-import sys,string,os,re
-
-### Platform specific APIs
-
-_libc_search = re.compile(r'(__libc_init)'
-                          '|'
-                          '(GLIBC_([0-9.]+))'
-                          '|'
-                          '(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)')
-
-def libc_ver(executable=sys.executable,lib='',version='',
-
-             chunksize=2048):
-
-    """ Tries to determine the libc version that the file executable
-        (which defaults to the Python interpreter) is linked against.
-
-        Returns a tuple of strings (lib,version) which default to the
-        given parameters in case the lookup fails.
-
-        Note that the function has intimate knowledge of how different
-        libc versions add symbols to the executable and thus is probably
-        only useable for executables compiled using gcc.
-
-        The file is read and scanned in chunks of chunksize bytes.
-
-    """
-    f = open(executable,'rb')
-    binary = f.read(chunksize)
-    pos = 0
-    while 1:
-        m = _libc_search.search(binary,pos)
-        if not m:
-            binary = f.read(chunksize)
-            if not binary:
-                break
-            pos = 0
-            continue
-        libcinit,glibc,glibcversion,so,threads,soversion = m.groups()
-        if libcinit and not lib:
-            lib = 'libc'
-        elif glibc:
-            if lib != 'glibc':
-                lib = 'glibc'
-                version = glibcversion
-            elif glibcversion > version:
-                version = glibcversion
-        elif so:
-            if lib != 'glibc':
-                lib = 'libc'
-                if soversion > version:
-                    version = soversion
-                if threads and version[-len(threads):] != threads:
-                    version = version + threads
-        pos = m.end()
-    f.close()
-    return lib,version
-
-def _dist_try_harder(distname,version,id):
-
-    """ Tries some special tricks to get the distribution
-        information in case the default method fails.
-
-        Currently supports older SuSE Linux, Caldera OpenLinux and
-        Slackware Linux distributions.
-
-    """
-    if os.path.exists('/var/adm/inst-log/info'):
-        # SuSE Linux stores distribution information in that file
-        info = open('/var/adm/inst-log/info').readlines()
-        distname = 'SuSE'
-        for line in info:
-            tv = string.split(line)
-            if len(tv) == 2:
-                tag,value = tv
-            else:
-                continue
-            if tag == 'MIN_DIST_VERSION':
-                version = string.strip(value)
-            elif tag == 'DIST_IDENT':
-                values = string.split(value,'-')
-                id = values[2]
-        return distname,version,id
-
-    if os.path.exists('/etc/.installed'):
-        # Caldera OpenLinux has some infos in that file (thanks to Colin Kong)
-        info = open('/etc/.installed').readlines()
-        for line in info:
-            pkg = string.split(line,'-')
-            if len(pkg) >= 2 and pkg[0] == 'OpenLinux':
-                # XXX does Caldera support non Intel platforms ? If yes,
-                #     where can we find the needed id ?
-                return 'OpenLinux',pkg[1],id
-
-    if os.path.isdir('/usr/lib/setup'):
-        # Check for slackware verson tag file (thanks to Greg Andruk)
-        verfiles = os.listdir('/usr/lib/setup')
-        for n in range(len(verfiles)-1, -1, -1):
-            if verfiles[n][:14] != 'slack-version-':
-                del verfiles[n]
-        if verfiles:
-            verfiles.sort()
-            distname = 'slackware'
-            version = verfiles[-1][14:]
-            return distname,version,id
-
-    return distname,version,id
-
-_release_filename = re.compile(r'(\w+)[-_](release|version)')
-_release_version = re.compile(r'([\d.]+)[^(]*(?:\((.+)\))?')
-
-# Note:In supported_dists below we need 'fedora' before 'redhat' as in
-# Fedora redhat-release is a link to fedora-release.
-
-def dist(distname='',version='',id='',
-
-         supported_dists=('SuSE', 'debian', 'fedora', 'redhat', 'mandrake')):
-
-    """ Tries to determine the name of the Linux OS distribution name.
-
-        The function first looks for a distribution release file in
-        /etc and then reverts to _dist_try_harder() in case no
-        suitable files are found.
-
-        Returns a tuple (distname,version,id) which default to the
-        args given as parameters.
-
-    """
-    try:
-        etc = os.listdir('/etc')
-    except os.error:
-        # Probably not a Unix system
-        return distname,version,id
-    for file in etc:
-        m = _release_filename.match(file)
-        if m:
-            _distname,dummy = m.groups()
-            if _distname in supported_dists:
-                distname = _distname
-                break
-    else:
-        return _dist_try_harder(distname,version,id)
-    f = open('/etc/'+file,'r')
-    firstline = f.readline()
-    f.close()
-    m = _release_version.search(firstline)
-    if m:
-        _version,_id = m.groups()
-        if _version:
-            version = _version
-        if _id:
-            id = _id
-    else:
-        # Unkown format... take the first two words
-        l = string.split(string.strip(firstline))
-        if l:
-            version = l[0]
-            if len(l) > 1:
-                id = l[1]
-    return distname,version,id
-
-class _popen:
-
-    """ Fairly portable (alternative) popen implementation.
-
-        This is mostly needed in case os.popen() is not available, or
-        doesn't work as advertised, e.g. in Win9X GUI programs like
-        PythonWin or IDLE.
-
-        Writing to the pipe is currently not supported.
-
-    """
-    tmpfile = ''
-    pipe = None
-    bufsize = None
-    mode = 'r'
-
-    def __init__(self,cmd,mode='r',bufsize=None):
-
-        if mode != 'r':
-            raise ValueError,'popen()-emulation only supports read mode'
-        import tempfile
-        self.tmpfile = tmpfile = tempfile.mktemp()
-        os.system(cmd + ' > %s' % tmpfile)
-        self.pipe = open(tmpfile,'rb')
-        self.bufsize = bufsize
-        self.mode = mode
-
-    def read(self):
-
-        return self.pipe.read()
-
-    def readlines(self):
-
-        if self.bufsize is not None:
-            return self.pipe.readlines()
-
-    def close(self,
-
-              remove=os.unlink,error=os.error):
-
-        if self.pipe:
-            rc = self.pipe.close()
-        else:
-            rc = 255
-        if self.tmpfile:
-            try:
-                remove(self.tmpfile)
-            except error:
-                pass
-        return rc
-
-    # Alias
-    __del__ = close
-
-def popen(cmd, mode='r', bufsize=None):
-
-    """ Portable popen() interface.
-    """
-    # Find a working popen implementation preferring win32pipe.popen
-    # over os.popen over _popen
-    popen = None
-    if os.environ.get('OS','') == 'Windows_NT':
-        # On NT win32pipe should work; on Win9x it hangs due to bugs
-        # in the MS C lib (see MS KnowledgeBase article Q150956)
-        try:
-            import win32pipe
-        except ImportError:
-            pass
-        else:
-            popen = win32pipe.popen
-    if popen is None:
-        if hasattr(os,'popen'):
-            popen = os.popen
-            # Check whether it works... it doesn't in GUI programs
-            # on Windows platforms
-            if sys.platform == 'win32': # XXX Others too ?
-                try:
-                    popen('')
-                except os.error:
-                    popen = _popen
-        else:
-            popen = _popen
-    if bufsize is None:
-        return popen(cmd,mode)
-    else:
-        return popen(cmd,mode,bufsize)
-
-def _norm_version(version,build=''):
-
-    """ Normalize the version and build strings and return a single
-        version string using the format major.minor.build (or patchlevel).
-    """
-    l = string.split(version,'.')
-    if build:
-        l.append(build)
-    try:
-        ints = map(int,l)
-    except ValueError:
-        strings = l
-    else:
-        strings = map(str,ints)
-    version = string.join(strings[:3],'.')
-    return version
-
-_ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
-                         '.*'
-                         'Version ([\d.]+))')
-
-def _syscmd_ver(system='',release='',version='',
-
-               supported_platforms=('win32','win16','dos','os2')):
-
-    """ Tries to figure out the OS version used and returns
-        a tuple (system,release,version).
-
-        It uses the "ver" shell command for this which is known
-        to exists on Windows, DOS and OS/2. XXX Others too ?
-
-        In case this fails, the given parameters are used as
-        defaults.
-
-    """
-    if sys.platform not in supported_platforms:
-        return system,release,version
-
-    # Try some common cmd strings
-    for cmd in ('ver','command /c ver','cmd /c ver'):
-        try:
-            pipe = popen(cmd)
-            info = pipe.read()
-            if pipe.close():
-                raise os.error,'command failed'
-            # XXX How can I supress shell errors from being written
-            #     to stderr ?
-        except os.error,why:
-            #print 'Command %s failed: %s' % (cmd,why)
-            continue
-        except IOError,why:
-            #print 'Command %s failed: %s' % (cmd,why)
-            continue
-        else:
-            break
-    else:
-        return system,release,version
-
-    # Parse the output
-    info = string.strip(info)
-    m = _ver_output.match(info)
-    if m:
-        system,release,version = m.groups()
-        # Strip trailing dots from version and release
-        if release[-1] == '.':
-            release = release[:-1]
-        if version[-1] == '.':
-            version = version[:-1]
-        # Normalize the version and build strings (eliminating additional
-        # zeros)
-        version = _norm_version(version)
-    return system,release,version
-
-def _win32_getvalue(key,name,default=''):
-
-    """ Read a value for name from the registry key.
-
-        In case this fails, default is returned.
-
-    """
-    from win32api import RegQueryValueEx
-    try:
-        return RegQueryValueEx(key,name)
-    except:
-        return default
-
-def win32_ver(release='',version='',csd='',ptype=''):
-
-    """ Get additional version information from the Windows Registry
-        and return a tuple (version,csd,ptype) referring to version
-        number, CSD level and OS type (multi/single
-        processor).
-
-        As a hint: ptype returns 'Uniprocessor Free' on single
-        processor NT machines and 'Multiprocessor Free' on multi
-        processor machines. The 'Free' refers to the OS version being
-        free of debugging code. It could also state 'Checked' which
-        means the OS version uses debugging code, i.e. code that
-        checks arguments, ranges, etc. (Thomas Heller).
-
-        Note: this function only works if Mark Hammond's win32
-        package is installed and obviously only runs on Win32
-        compatible platforms.
-
-    """
-    # XXX Is there any way to find out the processor type on WinXX ?
-    # XXX Is win32 available on Windows CE ?
-    #
-    # Adapted from code posted by Karl Putland to comp.lang.python.
-    #
-    # The mappings between reg. values and release names can be found
-    # here: http://msdn.microsoft.com/library/en-us/sysinfo/base/osversioninfo_str.asp
-
-    # Import the needed APIs
-    try:
-        import win32api
-    except ImportError:
-        return release,version,csd,ptype
-    from win32api import RegQueryValueEx,RegOpenKeyEx,RegCloseKey,GetVersionEx
-    from win32con import HKEY_LOCAL_MACHINE,VER_PLATFORM_WIN32_NT,\
-                         VER_PLATFORM_WIN32_WINDOWS
-
-    # Find out the registry key and some general version infos
-    maj,min,buildno,plat,csd = GetVersionEx()
-    version = '%i.%i.%i' % (maj,min,buildno & 0xFFFF)
-    if csd[:13] == 'Service Pack ':
-        csd = 'SP' + csd[13:]
-    if plat == VER_PLATFORM_WIN32_WINDOWS:
-        regkey = 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'
-        # Try to guess the release name
-        if maj == 4:
-            if min == 0:
-                release = '95'
-            elif min == 10:
-                release = '98'
-            elif min == 90:
-                release = 'Me'
-            else:
-                release = 'postMe'
-        elif maj == 5:
-            release = '2000'
-    elif plat == VER_PLATFORM_WIN32_NT:
-        regkey = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
-        if maj <= 4:
-            release = 'NT'
-        elif maj == 5:
-            if min == 0:
-                release = '2000'
-            elif min == 1:
-                release = 'XP'
-            elif min == 2:
-                release = '2003Server'
-            else:
-                release = 'post2003'
-    else:
-        if not release:
-            # E.g. Win3.1 with win32s
-            release = '%i.%i' % (maj,min)
-        return release,version,csd,ptype
-
-    # Open the registry key
-    try:
-        keyCurVer = RegOpenKeyEx(HKEY_LOCAL_MACHINE,regkey)
-        # Get a value to make sure the key exists...
-        RegQueryValueEx(keyCurVer,'SystemRoot')
-    except:
-        return release,version,csd,ptype
-
-    # Parse values
-    #subversion = _win32_getvalue(keyCurVer,
-    #                            'SubVersionNumber',
-    #                            ('',1))[0]
-    #if subversion:
-    #   release = release + subversion # 95a, 95b, etc.
-    build = _win32_getvalue(keyCurVer,
-                            'CurrentBuildNumber',
-                            ('',1))[0]
-    ptype = _win32_getvalue(keyCurVer,
-                           'CurrentType',
-                           (ptype,1))[0]
-
-    # Normalize version
-    version = _norm_version(version,build)
-
-    # Close key
-    RegCloseKey(keyCurVer)
-    return release,version,csd,ptype
-
-def _mac_ver_lookup(selectors,default=None):
-
-    from gestalt import gestalt
-    import MacOS
-    l = []
-    append = l.append
-    for selector in selectors:
-        try:
-            append(gestalt(selector))
-        except (RuntimeError, MacOS.Error):
-            append(default)
-    return l
-
-def _bcd2str(bcd):
-
-    return hex(bcd)[2:]
-
-def mac_ver(release='',versioninfo=('','',''),machine=''):
-
-    """ Get MacOS version information and return it as tuple (release,
-        versioninfo, machine) with versioninfo being a tuple (version,
-        dev_stage, non_release_version).
-
-        Entries which cannot be determined are set to the paramter values
-        which default to ''. All tuple entries are strings.
-
-        Thanks to Mark R. Levinson for mailing documentation links and
-        code examples for this function. Documentation for the
-        gestalt() API is available online at:
-
-           http://www.rgaros.nl/gestalt/
-
-    """
-    # Check whether the version info module is available
-    try:
-        import gestalt
-        import MacOS
-    except ImportError:
-        return release,versioninfo,machine
-    # Get the infos
-    sysv,sysu,sysa = _mac_ver_lookup(('sysv','sysu','sysa'))
-    # Decode the infos
-    if sysv:
-        major = (sysv & 0xFF00) >> 8
-        minor = (sysv & 0x00F0) >> 4
-        patch = (sysv & 0x000F)
-        release = '%s.%i.%i' % (_bcd2str(major),minor,patch)
-    if sysu:
-        major =  int((sysu & 0xFF000000L) >> 24)
-        minor =  (sysu & 0x00F00000) >> 20
-        bugfix = (sysu & 0x000F0000) >> 16
-        stage =  (sysu & 0x0000FF00) >> 8
-        nonrel = (sysu & 0x000000FF)
-        version = '%s.%i.%i' % (_bcd2str(major),minor,bugfix)
-        nonrel = _bcd2str(nonrel)
-        stage = {0x20:'development',
-                 0x40:'alpha',
-                 0x60:'beta',
-                 0x80:'final'}.get(stage,'')
-        versioninfo = (version,stage,nonrel)
-    if sysa:
-        machine = {0x1: '68k',
-                   0x2: 'PowerPC',
-                   0xa: 'i386'}.get(sysa,'')
-    return release,versioninfo,machine
-
-def _java_getprop(name,default):
-
-    from java.lang import System
-    try:
-        return System.getProperty(name)
-    except:
-        return default
-
-def java_ver(release='',vendor='',vminfo=('','',''),osinfo=('','','')):
-
-    """ Version interface for Jython.
-
-        Returns a tuple (release,vendor,vminfo,osinfo) with vminfo being
-        a tuple (vm_name,vm_release,vm_vendor) and osinfo being a
-        tuple (os_name,os_version,os_arch).
-
-        Values which cannot be determined are set to the defaults
-        given as parameters (which all default to '').
-
-    """
-    # Import the needed APIs
-    try:
-        import java.lang
-    except ImportError:
-        return release,vendor,vminfo,osinfo
-
-    vendor = _java_getprop('java.vendor',vendor)
-    release = _java_getprop('java.version',release)
-    vm_name,vm_release,vm_vendor = vminfo
-    vm_name = _java_getprop('java.vm.name',vm_name)
-    vm_vendor = _java_getprop('java.vm.vendor',vm_vendor)
-    vm_release = _java_getprop('java.vm.version',vm_release)
-    vminfo = vm_name,vm_release,vm_vendor
-    os_name,os_version,os_arch = osinfo
-    os_arch = _java_getprop('java.os.arch',os_arch)
-    os_name = _java_getprop('java.os.name',os_name)
-    os_version = _java_getprop('java.os.version',os_version)
-    osinfo = os_name,os_version,os_arch
-
-    return release,vendor,vminfo,osinfo
-
-### System name aliasing
-
-def system_alias(system,release,version):
-
-    """ Returns (system,release,version) aliased to common
-        marketing names used for some systems.
-
-        It also does some reordering of the information in some cases
-        where it would otherwise cause confusion.
-
-    """
-    if system == 'Rhapsody':
-        # Apple's BSD derivative
-        # XXX How can we determine the marketing release number ?
-        return 'MacOS X Server',system+release,version
-
-    elif system == 'SunOS':
-        # Sun's OS
-        if release < '5':
-            # These releases use the old name SunOS
-            return system,release,version
-        # Modify release (marketing release = SunOS release - 3)
-        l = string.split(release,'.')
-        if l:
-            try:
-                major = int(l[0])
-            except ValueError:
-                pass
-            else:
-                major = major - 3
-                l[0] = str(major)
-                release = string.join(l,'.')
-        if release < '6':
-            system = 'Solaris'
-        else:
-            # XXX Whatever the new SunOS marketing name is...
-            system = 'Solaris'
-
-    elif system == 'IRIX64':
-        # IRIX reports IRIX64 on platforms with 64-bit support; yet it
-        # is really a version and not a different platform, since 32-bit
-        # apps are also supported..
-        system = 'IRIX'
-        if version:
-            version = version + ' (64bit)'
-        else:
-            version = '64bit'
-
-    elif system in ('win32','win16'):
-        # In case one of the other tricks
-        system = 'Windows'
-
-    return system,release,version
-
-### Various internal helpers
-
-def _platform(*args):
-
-    """ Helper to format the platform string in a filename
-        compatible format e.g. "system-version-machine".
-    """
-    # Format the platform string
-    platform = string.join(
-        map(string.strip,
-            filter(len,args)),
-        '-')
-
-    # Cleanup some possible filename obstacles...
-    replace = string.replace
-    platform = replace(platform,' ','_')
-    platform = replace(platform,'/','-')
-    platform = replace(platform,'\\','-')
-    platform = replace(platform,':','-')
-    platform = replace(platform,';','-')
-    platform = replace(platform,'"','-')
-    platform = replace(platform,'(','-')
-    platform = replace(platform,')','-')
-
-    # No need to report 'unknown' information...
-    platform = replace(platform,'unknown','')
-
-    # Fold '--'s and remove trailing '-'
-    while 1:
-        cleaned = replace(platform,'--','-')
-        if cleaned == platform:
-            break
-        platform = cleaned
-    while platform[-1] == '-':
-        platform = platform[:-1]
-
-    return platform
-
-def _node(default=''):
-
-    """ Helper to determine the node name of this machine.
-    """
-    try:
-        import socket
-    except ImportError:
-        # No sockets...
-        return default
-    try:
-        return socket.gethostname()
-    except socket.error:
-        # Still not working...
-        return default
-
-# os.path.abspath is new in Python 1.5.2:
-if not hasattr(os.path,'abspath'):
-
-    def _abspath(path,
-
-                 isabs=os.path.isabs,join=os.path.join,getcwd=os.getcwd,
-                 normpath=os.path.normpath):
-
-        if not isabs(path):
-            path = join(getcwd(), path)
-        return normpath(path)
-
-else:
-
-    _abspath = os.path.abspath
-
-def _follow_symlinks(filepath):
-
-    """ In case filepath is a symlink, follow it until a
-        real file is reached.
-    """
-    filepath = _abspath(filepath)
-    while os.path.islink(filepath):
-        filepath = os.path.normpath(
-            os.path.join(filepath,os.readlink(filepath)))
-    return filepath
-
-def _syscmd_uname(option,default=''):
-
-    """ Interface to the system's uname command.
-    """
-    if sys.platform in ('dos','win32','win16','os2'):
-        # XXX Others too ?
-        return default
-    try:
-        f = os.popen('uname %s 2> /dev/null' % option)
-    except (AttributeError,os.error):
-        return default
-    output = string.strip(f.read())
-    rc = f.close()
-    if not output or rc:
-        return default
-    else:
-        return output
-
-def _syscmd_file(target,default=''):
-
-    """ Interface to the system's file command.
-
-        The function uses the -b option of the file command to have it
-        ommit the filename in its output and if possible the -L option
-        to have the command follow symlinks. It returns default in
-        case the command should fail.
-
-    """
-    target = _follow_symlinks(target)
-    try:
-        f = os.popen('file %s 2> /dev/null' % target)
-    except (AttributeError,os.error):
-        return default
-    output = string.strip(f.read())
-    rc = f.close()
-    if not output or rc:
-        return default
-    else:
-        return output
-
-### Information about the used architecture
-
-# Default values for architecture; non-empty strings override the
-# defaults given as parameters
-_default_architecture = {
-    'win32': ('','WindowsPE'),
-    'win16': ('','Windows'),
-    'dos': ('','MSDOS'),
-}
-
-_architecture_split = re.compile(r'[\s,]').split
-
-def architecture(executable=sys.executable,bits='',linkage=''):
-
-    """ Queries the given executable (defaults to the Python interpreter
-        binary) for various architecture information.
-
-        Returns a tuple (bits,linkage) which contains information about
-        the bit architecture and the linkage format used for the
-        executable. Both values are returned as strings.
-
-        Values that cannot be determined are returned as given by the
-        parameter presets. If bits is given as '', the sizeof(pointer)
-        (or sizeof(long) on Python version < 1.5.2) is used as
-        indicator for the supported pointer size.
-
-        The function relies on the system's "file" command to do the
-        actual work. This is available on most if not all Unix
-        platforms. On some non-Unix platforms where the "file" command
-        does not exist and the executable is set to the Python interpreter
-        binary defaults from _default_architecture are used.
-
-    """
-    # Use the sizeof(pointer) as default number of bits if nothing
-    # else is given as default.
-    if not bits:
-        import struct
-        try:
-            size = struct.calcsize('P')
-        except struct.error:
-            # Older installations can only query longs
-            size = struct.calcsize('l')
-        bits = str(size*8) + 'bit'
-
-    # Get data from the 'file' system command
-    output = _syscmd_file(executable,'')
-
-    if not output and \
-       executable == sys.executable:
-        # "file" command did not return anything; we'll try to provide
-        # some sensible defaults then...
-        if _default_architecture.has_key(sys.platform):
-            b,l = _default_architecture[sys.platform]
-            if b:
-                bits = b
-            if l:
-                linkage = l
-        return bits,linkage
-
-    # Split the output into a list of strings omitting the filename
-    fileout = _architecture_split(output)[1:]
-
-    if 'executable' not in fileout:
-        # Format not supported
-        return bits,linkage
-
-    # Bits
-    if '32-bit' in fileout:
-        bits = '32bit'
-    elif 'N32' in fileout:
-        # On Irix only
-        bits = 'n32bit'
-    elif '64-bit' in fileout:
-        bits = '64bit'
-
-    # Linkage
-    if 'ELF' in fileout:
-        linkage = 'ELF'
-    elif 'PE' in fileout:
-        # E.g. Windows uses this format
-        if 'Windows' in fileout:
-            linkage = 'WindowsPE'
-        else:
-            linkage = 'PE'
-    elif 'COFF' in fileout:
-        linkage = 'COFF'
-    elif 'MS-DOS' in fileout:
-        linkage = 'MSDOS'
-    else:
-        # XXX the A.OUT format also falls under this class...
-        pass
-
-    return bits,linkage
-
-### Portable uname() interface
-
-_uname_cache = None
-
-def uname():
-
-    """ Fairly portable uname interface. Returns a tuple
-        of strings (system,node,release,version,machine,processor)
-        identifying the underlying platform.
-
-        Note that unlike the os.uname function this also returns
-        possible processor information as an additional tuple entry.
-
-        Entries which cannot be determined are set to ''.
-
-    """
-    global _uname_cache
-
-    if _uname_cache is not None:
-        return _uname_cache
-
-    # Get some infos from the builtin os.uname API...
-    try:
-        system,node,release,version,machine = os.uname()
-
-    except AttributeError:
-        # Hmm, no uname... we'll have to poke around the system then.
-        system = sys.platform
-        release = ''
-        version = ''
-        node = _node()
-        machine = ''
-        processor = ''
-        use_syscmd_ver = 1
-
-        # Try win32_ver() on win32 platforms
-        if system == 'win32':
-            release,version,csd,ptype = win32_ver()
-            if release and version:
-                use_syscmd_ver = 0
-
-        # Try the 'ver' system command available on some
-        # platforms
-        if use_syscmd_ver:
-            system,release,version = _syscmd_ver(system)
-            # Normalize system to what win32_ver() normally returns
-            # (_syscmd_ver() tends to return the vendor name as well)
-            if system == 'Microsoft Windows':
-                system = 'Windows'
-
-        # In case we still don't know anything useful, we'll try to
-        # help ourselves
-        if system in ('win32','win16'):
-            if not version:
-                if system == 'win32':
-                    version = '32bit'
-                else:
-                    version = '16bit'
-            system = 'Windows'
-
-        elif system[:4] == 'java':
-            release,vendor,vminfo,osinfo = java_ver()
-            system = 'Java'
-            version = string.join(vminfo,', ')
-            if not version:
-                version = vendor
-
-        elif os.name == 'mac':
-            release,(version,stage,nonrel),machine = mac_ver()
-            system = 'MacOS'
-
-    else:
-        # System specific extensions
-        if system == 'OpenVMS':
-            # OpenVMS seems to have release and version mixed up
-            if not release or release == '0':
-                release = version
-                version = ''
-            # Get processor information
-            try:
-                import vms_lib
-            except ImportError:
-                pass
-            else:
-                csid, cpu_number = vms_lib.getsyi('SYI$_CPU',0)
-                if (cpu_number >= 128):
-                    processor = 'Alpha'
-                else:
-                    processor = 'VAX'
-        else:
-            # Get processor information from the uname system command
-            processor = _syscmd_uname('-p','')
-
-    # 'unknown' is not really any useful as information; we'll convert
-    # it to '' which is more portable
-    if system == 'unknown':
-        system = ''
-    if node == 'unknown':
-        node = ''
-    if release == 'unknown':
-        release = ''
-    if version == 'unknown':
-        version = ''
-    if machine == 'unknown':
-        machine = ''
-    if processor == 'unknown':
-        processor = ''
-    _uname_cache = system,node,release,version,machine,processor
-    return _uname_cache
-
-### Direct interfaces to some of the uname() return values
-
-def system():
-
-    """ Returns the system/OS name, e.g. 'Linux', 'Windows' or 'Java'.
-
-        An empty string is returned if the value cannot be determined.
-
-    """
-    return uname()[0]
-
-def node():
-
-    """ Returns the computer's network name (which may not be fully
-        qualified)
-
-        An empty string is returned if the value cannot be determined.
-
-    """
-    return uname()[1]
-
-def release():
-
-    """ Returns the system's release, e.g. '2.2.0' or 'NT'
-
-        An empty string is returned if the value cannot be determined.
-
-    """
-    return uname()[2]
-
-def version():
-
-    """ Returns the system's release version, e.g. '#3 on degas'
-
-        An empty string is returned if the value cannot be determined.
-
-    """
-    return uname()[3]
-
-def machine():
-
-    """ Returns the machine type, e.g. 'i386'
-
-        An empty string is returned if the value cannot be determined.
-
-    """
-    return uname()[4]
-
-def processor():
-
-    """ Returns the (true) processor name, e.g. 'amdk6'
-
-        An empty string is returned if the value cannot be
-        determined. Note that many platforms do not provide this
-        information or simply return the same value as for machine(),
-        e.g.  NetBSD does this.
-
-    """
-    return uname()[5]
-
-### Various APIs for extracting information from sys.version
-
-_sys_version_parser = re.compile(r'([\w.+]+)\s*'
-                                  '\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
-                                  '\[([^\]]+)\]?')
-_sys_version_cache = None
-
-def _sys_version():
-
-    """ Returns a parsed version of Python's sys.version as tuple
-        (version, buildno, builddate, compiler) referring to the Python
-        version, build number, build date/time as string and the compiler
-        identification string.
-
-        Note that unlike the Python sys.version, the returned value
-        for the Python version will always include the patchlevel (it
-        defaults to '.0').
-
-    """
-    global _sys_version_cache
-
-    if _sys_version_cache is not None:
-        return _sys_version_cache
-    version, buildno, builddate, buildtime, compiler = \
-             _sys_version_parser.match(sys.version).groups()
-    builddate = builddate + ' ' + buildtime
-    l = string.split(version, '.')
-    if len(l) == 2:
-        l.append('0')
-        version = string.join(l, '.')
-    _sys_version_cache = (version, buildno, builddate, compiler)
-    return _sys_version_cache
-
-def python_version():
-
-    """ Returns the Python version as string 'major.minor.patchlevel'
-
-        Note that unlike the Python sys.version, the returned value
-        will always include the patchlevel (it defaults to 0).
-
-    """
-    return _sys_version()[0]
-
-def python_version_tuple():
-
-    """ Returns the Python version as tuple (major, minor, patchlevel)
-        of strings.
-
-        Note that unlike the Python sys.version, the returned value
-        will always include the patchlevel (it defaults to 0).
-
-    """
-    return string.split(_sys_version()[0], '.')
-
-def python_build():
-
-    """ Returns a tuple (buildno, builddate) stating the Python
-        build number and date as strings.
-
-    """
-    return _sys_version()[1:3]
-
-def python_compiler():
-
-    """ Returns a string identifying the compiler used for compiling
-        Python.
-
-    """
-    return _sys_version()[3]
-
-### The Opus Magnum of platform strings :-)
-
-_platform_cache = {}
-
-def platform(aliased=0, terse=0):
-
-    """ Returns a single string identifying the underlying platform
-        with as much useful information as possible (but no more :).
-
-        The output is intended to be human readable rather than
-        machine parseable. It may look different on different
-        platforms and this is intended.
-
-        If "aliased" is true, the function will use aliases for
-        various platforms that report system names which differ from
-        their common names, e.g. SunOS will be reported as
-        Solaris. The system_alias() function is used to implement
-        this.
-
-        Setting terse to true causes the function to return only the
-        absolute minimum information needed to identify the platform.
-
-    """
-    result = _platform_cache.get((aliased, terse), None)
-    if result is not None:
-        return result
-
-    # Get uname information and then apply platform specific cosmetics
-    # to it...
-    system,node,release,version,machine,processor = uname()
-    if machine == processor:
-        processor = ''
-    if aliased:
-        system,release,version = system_alias(system,release,version)
-
-    if system == 'Windows':
-        # MS platforms
-        rel,vers,csd,ptype = win32_ver(version)
-        if terse:
-            platform = _platform(system,release)
-        else:
-            platform = _platform(system,release,version,csd)
-
-    elif system in ('Linux',):
-        # Linux based systems
-        distname,distversion,distid = dist('')
-        if distname and not terse:
-            platform = _platform(system,release,machine,processor,
-                                 'with',
-                                 distname,distversion,distid)
-        else:
-            # If the distribution name is unknown check for libc vs. glibc
-            libcname,libcversion = libc_ver(sys.executable)
-            platform = _platform(system,release,machine,processor,
-                                 'with',
-                                 libcname+libcversion)
-    elif system == 'Java':
-        # Java platforms
-        r,v,vminfo,(os_name,os_version,os_arch) = java_ver()
-        if terse:
-            platform = _platform(system,release,version)
-        else:
-            platform = _platform(system,release,version,
-                                 'on',
-                                 os_name,os_version,os_arch)
-
-    elif system == 'MacOS':
-        # MacOS platforms
-        if terse:
-            platform = _platform(system,release)
-        else:
-            platform = _platform(system,release,machine)
-
-    else:
-        # Generic handler
-        if terse:
-            platform = _platform(system,release)
-        else:
-            bits,linkage = architecture(sys.executable)
-            platform = _platform(system,release,machine,processor,bits,linkage)
-
-    _platform_cache[(aliased, terse)] = platform
-    return platform
-
-### Command line interface
-
-if __name__ == '__main__':
-    # Default is to print the aliased verbose platform string
-    terse = ('terse' in sys.argv or '--terse' in sys.argv)
-    aliased = (not 'nonaliased' in sys.argv and not '--nonaliased' in sys.argv)
-    print platform(aliased,terse)
-    sys.exit(0)
diff --git a/Tools/pybench/pybench-2.0/pybench.py b/Tools/pybench/pybench-2.0/pybench.py
deleted file mode 100755
index 8ff16c5..0000000
--- a/Tools/pybench/pybench-2.0/pybench.py
+++ /dev/null
@@ -1,938 +0,0 @@
-#!/usr/local/bin/python -O
-
-""" A Python Benchmark Suite
-
-"""
-#
-# Note: Please keep this module compatible to Python 1.5.2.
-#
-# Tests may include features in later Python versions, but these
-# should then be embedded in try-except clauses in the configuration
-# module Setup.py.
-#
-
-# pybench Copyright
-__copyright__ = """\
-Copyright (c), 1997-2006, Marc-Andre Lemburg (mal@lemburg.com)
-Copyright (c), 2000-2006, eGenix.com Software GmbH (info@egenix.com)
-
-                   All Rights Reserved.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee or royalty is hereby
-granted, provided that the above copyright notice appear in all copies
-and that both that copyright notice and this permission notice appear
-in supporting documentation or portions thereof, including
-modifications, that you make.
-
-THE AUTHOR MARC-ANDRE LEMBURG DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
-INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
-FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
-"""
-
-import sys, time, operator, string
-from CommandLine import *
-
-try:
-    import cPickle
-    pickle = cPickle
-except ImportError:
-    import pickle
-
-# Version number; version history: see README file !
-__version__ = '2.0'
-
-### Constants
-
-# Second fractions
-MILLI_SECONDS = 1e3
-MICRO_SECONDS = 1e6
-
-# Percent unit
-PERCENT = 100
-
-# Horizontal line length
-LINE = 79
-
-# Minimum test run-time
-MIN_TEST_RUNTIME = 1e-3
-
-# Number of calibration runs to use for calibrating the tests
-CALIBRATION_RUNS = 20
-
-# Number of calibration loops to run for each calibration run
-CALIBRATION_LOOPS = 20
-
-# Allow skipping calibration ?
-ALLOW_SKIPPING_CALIBRATION = 1
-
-# Timer types
-TIMER_TIME_TIME = 'time.time'
-TIMER_TIME_CLOCK = 'time.clock'
-TIMER_SYSTIMES_PROCESSTIME = 'systimes.processtime'
-
-# Choose platform default timer
-if sys.platform[:3] == 'win':
-    # On WinXP this has 2.5ms resolution
-    TIMER_PLATFORM_DEFAULT = TIMER_TIME_CLOCK
-else:
-    # On Linux this has 1ms resolution
-    TIMER_PLATFORM_DEFAULT = TIMER_TIME_TIME
-
-# Print debug information ?
-_debug = 0
-
-### Helpers
-
-def get_timer(timertype):
-
-    if timertype == TIMER_TIME_TIME:
-        return time.time
-    elif timertype == TIMER_TIME_CLOCK:
-        return time.clock
-    elif timertype == TIMER_SYSTIMES_PROCESSTIME:
-        import systimes
-        return systimes.processtime
-    else:
-        raise TypeError('unknown timer type: %s' % timertype)
-
-def get_machine_details():
-
-    import platform
-    if _debug:
-        print 'Getting machine details...'
-    buildno, builddate = platform.python_build()
-    python = platform.python_version()
-    if python > '2.0':
-        try:
-            unichr(100000)
-        except ValueError:
-            # UCS2 build (standard)
-            unicode = 'UCS2'
-        else:
-            # UCS4 build (most recent Linux distros)
-            unicode = 'UCS4'
-    else:
-        unicode = None
-    bits, linkage = platform.architecture()
-    return {
-        'platform': platform.platform(),
-        'processor': platform.processor(),
-        'executable': sys.executable,
-        'python': platform.python_version(),
-        'compiler': platform.python_compiler(),
-        'buildno': buildno,
-        'builddate': builddate,
-        'unicode': unicode,
-        'bits': bits,
-        }
-
-def print_machine_details(d, indent=''):
-
-    l = ['Machine Details:',
-         '   Platform ID:  %s' % d.get('platform', 'n/a'),
-         '   Processor:    %s' % d.get('processor', 'n/a'),
-         '',
-         'Python:',
-         '   Executable:   %s' % d.get('executable', 'n/a'),
-         '   Version:      %s' % d.get('python', 'n/a'),
-         '   Compiler:     %s' % d.get('compiler', 'n/a'),
-         '   Bits:         %s' % d.get('bits', 'n/a'),
-         '   Build:        %s (#%s)' % (d.get('builddate', 'n/a'),
-                                        d.get('buildno', 'n/a')),
-         '   Unicode:      %s' % d.get('unicode', 'n/a'),
-         ]
-    print indent + string.join(l, '\n' + indent) + '\n'
-
-### Test baseclass
-
-class Test:
-
-    """ All test must have this class as baseclass. It provides
-        the necessary interface to the benchmark machinery.
-
-        The tests must set .rounds to a value high enough to let the
-        test run between 20-50 seconds. This is needed because
-        clock()-timing only gives rather inaccurate values (on Linux,
-        for example, it is accurate to a few hundreths of a
-        second). If you don't want to wait that long, use a warp
-        factor larger than 1.
-
-        It is also important to set the .operations variable to a
-        value representing the number of "virtual operations" done per
-        call of .run().
-
-        If you change a test in some way, don't forget to increase
-        it's version number.
-
-    """
-
-    ### Instance variables that each test should override
-
-    # Version number of the test as float (x.yy); this is important
-    # for comparisons of benchmark runs - tests with unequal version
-    # number will not get compared.
-    version = 2.0
-
-    # The number of abstract operations done in each round of the
-    # test. An operation is the basic unit of what you want to
-    # measure. The benchmark will output the amount of run-time per
-    # operation. Note that in order to raise the measured timings
-    # significantly above noise level, it is often required to repeat
-    # sets of operations more than once per test round. The measured
-    # overhead per test round should be less than 1 second.
-    operations = 1
-
-    # Number of rounds to execute per test run. This should be
-    # adjusted to a figure that results in a test run-time of between
-    # 1-2 seconds.
-    rounds = 100000
-
-    ### Internal variables
-
-    # Mark this class as implementing a test
-    is_a_test = 1
-
-    # Last timing: (real, run, overhead)
-    last_timing = (0.0, 0.0, 0.0)
-
-    # Warp factor to use for this test
-    warp = 1
-
-    # Number of calibration runs to use
-    calibration_runs = CALIBRATION_RUNS
-
-    # List of calibration timings
-    overhead_times = None
-
-    # List of test run timings
-    times = []
-
-    # Timer used for the benchmark
-    timer = TIMER_PLATFORM_DEFAULT
-
-    def __init__(self, warp=None, calibration_runs=None, timer=None):
-
-        # Set parameters
-        if warp is not None:
-            self.rounds = int(self.rounds / warp)
-            if self.rounds == 0:
-                raise ValueError('warp factor set too high')
-            self.warp = warp
-        if calibration_runs is not None:
-            if (not ALLOW_SKIPPING_CALIBRATION and
-                calibration_runs < 1):
-                raise ValueError('at least one calibration run is required')
-            self.calibration_runs = calibration_runs
-        if timer is not None:
-            timer = timer
-
-        # Init variables
-        self.times = []
-        self.overhead_times = []
-
-        # We want these to be in the instance dict, so that pickle
-        # saves them
-        self.version = self.version
-        self.operations = self.operations
-        self.rounds = self.rounds
-
-    def get_timer(self):
-
-        """ Return the timer function to use for the test.
-
-        """
-        return get_timer(self.timer)
-
-    def compatible(self, other):
-
-        """ Return 1/0 depending on whether the test is compatible
-            with the other Test instance or not.
-
-        """
-        if self.version != other.version:
-            return 0
-        if self.rounds != other.rounds:
-            return 0
-        return 1
-
-    def calibrate_test(self):
-
-        if self.calibration_runs == 0:
-            self.overhead_times = [0.0]
-            return
-
-        calibrate = self.calibrate
-        timer = self.get_timer()
-        calibration_loops = range(CALIBRATION_LOOPS)
-
-        # Time the calibration loop overhead
-        prep_times = []
-        for i in range(self.calibration_runs):
-            t = timer()
-            for i in calibration_loops:
-                pass
-            t = timer() - t
-            prep_times.append(t)
-        min_prep_time = min(prep_times)
-        if _debug:
-            print
-            print 'Calib. prep time     = %.6fms' % (
-                min_prep_time * MILLI_SECONDS)
-
-        # Time the calibration runs (doing CALIBRATION_LOOPS loops of
-        # .calibrate() method calls each)
-        for i in range(self.calibration_runs):
-            t = timer()
-            for i in calibration_loops:
-                calibrate()
-            t = timer() - t
-            self.overhead_times.append(t / CALIBRATION_LOOPS
-                                       - min_prep_time)
-
-        # Check the measured times
-        min_overhead = min(self.overhead_times)
-        max_overhead = max(self.overhead_times)
-        if _debug:
-            print 'Calib. overhead time = %.6fms' % (
-                min_overhead * MILLI_SECONDS)
-        if min_overhead < 0.0:
-            raise ValueError('calibration setup did not work')
-        if max_overhead - min_overhead > 0.1:
-            raise ValueError(
-                'overhead calibration timing range too inaccurate: '
-                '%r - %r' % (min_overhead, max_overhead))
-
-    def run(self):
-
-        """ Run the test in two phases: first calibrate, then
-            do the actual test. Be careful to keep the calibration
-            timing low w/r to the test timing.
-
-        """
-        test = self.test
-        timer = self.get_timer()
-
-        # Get calibration
-        min_overhead = min(self.overhead_times)
-
-        # Test run
-        t = timer()
-        test()
-        t = timer() - t
-        if t < MIN_TEST_RUNTIME:
-            raise ValueError('warp factor too high: '
-                             'test times are < 10ms')
-        eff_time = t - min_overhead
-        if eff_time < 0:
-            raise ValueError('wrong calibration')
-        self.last_timing = (eff_time, t, min_overhead)
-        self.times.append(eff_time)
-
-    def calibrate(self):
-
-        """ Calibrate the test.
-
-            This method should execute everything that is needed to
-            setup and run the test - except for the actual operations
-            that you intend to measure. pybench uses this method to
-            measure the test implementation overhead.
-
-        """
-        return
-
-    def test(self):
-
-        """ Run the test.
-
-            The test needs to run self.rounds executing
-            self.operations number of operations each.
-
-        """
-        return
-
-    def stat(self):
-
-        """ Return test run statistics as tuple:
-
-            (minimum run time,
-             average run time,
-             total run time,
-             average time per operation,
-             minimum overhead time)
-
-        """
-        runs = len(self.times)
-        if runs == 0:
-            return 0.0, 0.0, 0.0, 0.0
-        min_time = min(self.times)
-        total_time = reduce(operator.add, self.times, 0.0)
-        avg_time = total_time / float(runs)
-        operation_avg = total_time / float(runs
-                                           * self.rounds
-                                           * self.operations)
-        if self.overhead_times:
-            min_overhead = min(self.overhead_times)
-        else:
-            min_overhead = self.last_timing[2]
-        return min_time, avg_time, total_time, operation_avg, min_overhead
-
-### Load Setup
-
-# This has to be done after the definition of the Test class, since
-# the Setup module will import subclasses using this class.
-
-import Setup
-
-### Benchmark base class
-
-class Benchmark:
-
-    # Name of the benchmark
-    name = ''
-
-    # Number of benchmark rounds to run
-    rounds = 1
-
-    # Warp factor use to run the tests
-    warp = 1                    # Warp factor
-
-    # Average benchmark round time
-    roundtime = 0
-
-    # Benchmark version number as float x.yy
-    version = 2.0
-
-    # Produce verbose output ?
-    verbose = 0
-
-    # Dictionary with the machine details
-    machine_details = None
-
-    # Timer used for the benchmark
-    timer = TIMER_PLATFORM_DEFAULT
-
-    def __init__(self, name, verbose=None, timer=None, warp=None,
-                 calibration_runs=None):
-        
-        if name:
-            self.name = name
-        else:
-            self.name = '%04i-%02i-%02i %02i:%02i:%02i' % \
-                        (time.localtime(time.time())[:6])
-        if verbose is not None:
-            self.verbose = verbose
-        if timer is not None:
-            self.timer = timer
-        if warp is not None:
-            self.warp = warp
-        if calibration_runs is not None:
-            self.calibration_runs = calibration_runs
-
-        # Init vars
-        self.tests = {}
-        if _debug:
-            print 'Getting machine details...'
-        self.machine_details = get_machine_details()
-        
-        # Make .version an instance attribute to have it saved in the
-        # Benchmark pickle
-        self.version = self.version
-
-    def get_timer(self):
-
-        """ Return the timer function to use for the test.
-
-        """
-        return get_timer(self.timer)
-
-    def compatible(self, other):
-
-        """ Return 1/0 depending on whether the benchmark is
-            compatible with the other Benchmark instance or not.
-
-        """
-        if self.version != other.version:
-            return 0
-        if (self.machine_details == other.machine_details and
-            self.timer != other.timer):
-            return 0
-        if (self.calibration_runs == 0 and
-            other.calibration_runs != 0):
-            return 0
-        if (self.calibration_runs != 0 and
-            other.calibration_runs == 0):
-            return 0
-        return 1
-
-    def load_tests(self, setupmod, limitnames=None):
-
-        # Add tests
-        if self.verbose:
-            print 'Searching for tests ...'
-            print '--------------------------------------'
-        for testclass in setupmod.__dict__.values():
-            if not hasattr(testclass, 'is_a_test'):
-                continue
-            name = testclass.__name__
-            if  name == 'Test':
-                continue
-            if (limitnames is not None and
-                limitnames.search(name) is None):
-                continue
-            self.tests[name] = testclass(
-                warp=self.warp,
-                calibration_runs=self.calibration_runs,
-                timer=self.timer)
-        l = self.tests.keys()
-        l.sort()
-        if self.verbose:
-            for name in l:
-                print '  %s' % name
-            print '--------------------------------------'
-            print '  %i tests found' % len(l)
-            print
-
-    def calibrate(self):
-
-        print 'Calibrating tests. Please wait...'
-        if self.verbose:
-            print
-            print 'Test                              min      max'
-            print '-' * LINE
-        tests = self.tests.items()
-        tests.sort()
-        for i in range(len(tests)):
-            name, test = tests[i]
-            test.calibrate_test()
-            if self.verbose:
-                print '%30s:  %6.3fms  %6.3fms' % \
-                      (name,
-                       min(test.overhead_times) * MILLI_SECONDS,
-                       max(test.overhead_times) * MILLI_SECONDS)
-        print
-
-    def run(self):
-
-        tests = self.tests.items()
-        tests.sort()
-        timer = self.get_timer()
-        print 'Running %i round(s) of the suite at warp factor %i:' % \
-              (self.rounds, self.warp)
-        print
-        self.roundtimes = []
-        for i in range(self.rounds):
-            if self.verbose:
-                print ' Round %-25i  effective   absolute  overhead' % (i+1)
-            total_eff_time = 0.0
-            for j in range(len(tests)):
-                name, test = tests[j]
-                if self.verbose:
-                    print '%30s:' % name,
-                test.run()
-                (eff_time, abs_time, min_overhead) = test.last_timing
-                total_eff_time = total_eff_time + eff_time
-                if self.verbose:
-                    print '    %5.0fms    %5.0fms %7.3fms' % \
-                          (eff_time * MILLI_SECONDS,
-                           abs_time * MILLI_SECONDS,
-                           min_overhead * MILLI_SECONDS)
-            self.roundtimes.append(total_eff_time)
-            if self.verbose:
-                print ('                   '
-                       '               ------------------------------')
-                print ('                   '
-                       '     Totals:    %6.0fms' %
-                       (total_eff_time * MILLI_SECONDS))
-                print
-            else:
-                print '* Round %i done in %.3f seconds.' % (i+1,
-                                                            total_eff_time)
-        print
-
-    def stat(self):
-
-        """ Return benchmark run statistics as tuple:
-
-            (minimum round time,
-             average round time,
-             maximum round time)
-
-            XXX Currently not used, since the benchmark does test
-                statistics across all rounds.
-
-        """
-        runs = len(self.roundtimes)
-        if runs == 0:
-            return 0.0, 0.0
-        min_time = min(self.roundtimes)
-        total_time = reduce(operator.add, self.roundtimes, 0.0)
-        avg_time = total_time / float(runs)
-        max_time = max(self.roundtimes)
-        return (min_time, avg_time, max_time)
-
-    def print_header(self, title='Benchmark'):
-
-        print '-' * LINE
-        print '%s: %s' % (title, self.name)
-        print '-' * LINE
-        print
-        print '    Rounds: %s' % self.rounds
-        print '    Warp:   %s' % self.warp
-        print '    Timer:  %s' % self.timer
-        print
-        if self.machine_details:
-            print_machine_details(self.machine_details, indent='    ')
-            print
-
-    def print_benchmark(self, hidenoise=0, limitnames=None):
-
-        print ('Test                          '
-               '   minimum  average  operation  overhead')
-        print '-' * LINE
-        tests = self.tests.items()
-        tests.sort()
-        total_min_time = 0.0
-        total_avg_time = 0.0
-        for name, test in tests:
-            if (limitnames is not None and
-                limitnames.search(name) is None):
-                continue
-            (min_time,
-             avg_time,
-             total_time,
-             op_avg,
-             min_overhead) = test.stat()
-            total_min_time = total_min_time + min_time
-            total_avg_time = total_avg_time + avg_time
-            print '%30s:  %5.0fms  %5.0fms  %6.2fus  %7.3fms' % \
-                  (name,
-                   min_time * MILLI_SECONDS,
-                   avg_time * MILLI_SECONDS,
-                   op_avg * MICRO_SECONDS,
-                   min_overhead *MILLI_SECONDS)
-        print '-' * LINE
-        print ('Totals:                        '
-               ' %6.0fms %6.0fms' %
-               (total_min_time * MILLI_SECONDS,
-                total_avg_time * MILLI_SECONDS,
-                ))
-        print
-
-    def print_comparison(self, compare_to, hidenoise=0, limitnames=None):
-
-        # Check benchmark versions
-        if compare_to.version != self.version:
-            print ('* Benchmark versions differ: '
-                   'cannot compare this benchmark to "%s" !' %
-                   compare_to.name)
-            print
-            self.print_benchmark(hidenoise=hidenoise,
-                                 limitnames=limitnames)
-            return
-
-        # Print header
-        compare_to.print_header('Comparing with')
-        print ('Test                          '
-               '   minimum run-time        average  run-time')
-        print ('                              '
-               '   this    other   diff    this    other   diff')
-        print '-' * LINE
-
-        # Print test comparisons
-        tests = self.tests.items()
-        tests.sort()
-        total_min_time = other_total_min_time = 0.0
-        total_avg_time = other_total_avg_time = 0.0
-        benchmarks_compatible = self.compatible(compare_to)
-        tests_compatible = 1
-        for name, test in tests:
-            if (limitnames is not None and
-                limitnames.search(name) is None):
-                continue
-            (min_time,
-             avg_time,
-             total_time,
-             op_avg,
-             min_overhead) = test.stat()
-            total_min_time = total_min_time + min_time
-            total_avg_time = total_avg_time + avg_time
-            try:
-                other = compare_to.tests[name]
-            except KeyError:
-                other = None
-            if other is None:
-                # Other benchmark doesn't include the given test
-                min_diff, avg_diff = 'n/a', 'n/a'
-                other_min_time = 0.0
-                other_avg_time = 0.0
-                tests_compatible = 0
-            else:
-                (other_min_time,
-                 other_avg_time,
-                 other_total_time,
-                 other_op_avg,
-                 other_min_overhead) = other.stat()
-                other_total_min_time = other_total_min_time + other_min_time
-                other_total_avg_time = other_total_avg_time + other_avg_time
-                if (benchmarks_compatible and
-                    test.compatible(other)):
-                    # Both benchmark and tests are comparible
-                    min_diff = ((min_time * self.warp) /
-                                (other_min_time * other.warp) - 1.0)
-                    avg_diff = ((avg_time * self.warp) /
-                                (other_avg_time * other.warp) - 1.0)
-                    if hidenoise and abs(min_diff) < 10.0:
-                        min_diff = ''
-                    else:
-                        min_diff = '%+5.1f%%' % (min_diff * PERCENT)
-                    if hidenoise and abs(avg_diff) < 10.0:
-                        avg_diff = ''
-                    else:
-                        avg_diff = '%+5.1f%%' % (avg_diff * PERCENT)
-                else:
-                    # Benchmark or tests are not comparible
-                    min_diff, avg_diff = 'n/a', 'n/a'
-                    tests_compatible = 0
-            print '%30s: %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' % \
-                  (name,
-                   min_time * MILLI_SECONDS,
-                   other_min_time * MILLI_SECONDS * compare_to.warp / self.warp,
-                   min_diff,
-                   avg_time * MILLI_SECONDS,
-                   other_avg_time * MILLI_SECONDS * compare_to.warp / self.warp,
-                   avg_diff)
-        print '-' * LINE
-
-        # Summarise test results
-        if not benchmarks_compatible or not tests_compatible:
-            min_diff, avg_diff = 'n/a', 'n/a'
-        else:
-            if other_total_min_time != 0.0:
-                min_diff = '%+5.1f%%' % (
-                    ((total_min_time * self.warp) /
-                     (other_total_min_time * compare_to.warp) - 1.0) * PERCENT)
-            else:
-                min_diff = 'n/a'
-            if other_total_avg_time != 0.0:
-                avg_diff = '%+5.1f%%' % (
-                    ((total_avg_time * self.warp) /
-                     (other_total_avg_time * compare_to.warp) - 1.0) * PERCENT)
-            else:
-                avg_diff = 'n/a'
-        print ('Totals:                       '
-               '  %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' %
-               (total_min_time * MILLI_SECONDS,
-                (other_total_min_time * compare_to.warp/self.warp
-                 * MILLI_SECONDS),
-                min_diff,
-                total_avg_time * MILLI_SECONDS,
-                (other_total_avg_time * compare_to.warp/self.warp
-                 * MILLI_SECONDS),
-                avg_diff
-               ))
-        print
-        print '(this=%s, other=%s)' % (self.name,
-                                       compare_to.name)
-        print
-
-class PyBenchCmdline(Application):
-
-    header = ("PYBENCH - a benchmark test suite for Python "
-              "interpreters/compilers.")
-
-    version = __version__
-
-    debug = _debug
-
-    options = [ArgumentOption('-n',
-                              'number of rounds',
-                              Setup.Number_of_rounds),
-               ArgumentOption('-f',
-                              'save benchmark to file arg',
-                              ''),
-               ArgumentOption('-c',
-                              'compare benchmark with the one in file arg',
-                              ''),
-               ArgumentOption('-s',
-                              'show benchmark in file arg, then exit',
-                              ''),
-               ArgumentOption('-w',
-                              'set warp factor to arg',
-                              Setup.Warp_factor),
-               ArgumentOption('-t',
-                              'run only tests with names matching arg',
-                              ''),
-               ArgumentOption('-C',
-                              'set the number of calibration runs to arg',
-                              CALIBRATION_RUNS),
-               SwitchOption('-d',
-                            'hide noise in comparisons',
-                            0),
-               SwitchOption('-v',
-                            'verbose output (not recommended)',
-                            0),
-               SwitchOption('--with-gc',
-                            'enable garbage collection',
-                            0),
-               SwitchOption('--with-syscheck',
-                            'use default sys check interval',
-                            0),
-               ArgumentOption('--timer',
-                            'use given timer',
-                            TIMER_PLATFORM_DEFAULT),
-               ]
-
-    about = """\
-The normal operation is to run the suite and display the
-results. Use -f to save them for later reuse or comparisons.
-
-Available timers:
-
-   time.time
-   time.clock
-   systimes.processtime
-
-Examples:
-
-python2.1 pybench.py -f p21.pybench
-python2.5 pybench.py -f p25.pybench
-python pybench.py -s p25.pybench -c p21.pybench
-"""
-    copyright = __copyright__
-
-    def main(self):
-
-        rounds = self.values['-n']
-        reportfile = self.values['-f']
-        show_bench = self.values['-s']
-        compare_to = self.values['-c']
-        hidenoise = self.values['-d']
-        warp = int(self.values['-w'])
-        withgc = self.values['--with-gc']
-        limitnames = self.values['-t']
-        if limitnames:
-            if _debug:
-                print '* limiting test names to one with substring "%s"' % \
-                      limitnames
-            limitnames = re.compile(limitnames, re.I)
-        else:
-            limitnames = None
-        verbose = self.verbose
-        withsyscheck = self.values['--with-syscheck']
-        calibration_runs = self.values['-C']
-        timer = self.values['--timer']
-
-        print '-' * LINE
-        print 'PYBENCH %s' % __version__
-        print '-' * LINE
-        print '* using Python %s' % (string.split(sys.version)[0])
-
-        # Switch off garbage collection
-        if not withgc:
-            try:
-                import gc
-            except ImportError:
-                print '* Python version doesn\'t support garbage collection'
-            else:
-                gc.disable()
-                print '* disabled garbage collection'
-
-        # "Disable" sys check interval
-        if not withsyscheck:
-            # Too bad the check interval uses an int instead of a long...
-            value = 2147483647
-            sys.setcheckinterval(value)
-            print '* system check interval set to maximum: %s' % value
-
-        if timer == TIMER_SYSTIMES_PROCESSTIME:
-            import systimes
-            print '* using timer: systimes.processtime (%s)' % \
-                  systimes.SYSTIMES_IMPLEMENTATION
-        else:
-            print '* using timer: %s' % timer
-
-        print
-
-        if compare_to:
-            try:
-                f = open(compare_to,'rb')
-                bench = pickle.load(f)
-                bench.name = compare_to
-                f.close()
-                compare_to = bench
-            except IOError, reason:
-                print '* Error opening/reading file %s: %s' % (
-                    repr(compare_to),
-                    reason)
-                compare_to = None
-
-        if show_bench:
-            try:
-                f = open(show_bench,'rb')
-                bench = pickle.load(f)
-                bench.name = show_bench
-                f.close()
-                bench.print_header()
-                if compare_to:
-                    bench.print_comparison(compare_to,
-                                           hidenoise=hidenoise,
-                                           limitnames=limitnames)
-                else:
-                    bench.print_benchmark(hidenoise=hidenoise,
-                                          limitnames=limitnames)
-            except IOError:
-                print '* Error opening/reading file %s: %s' % (
-                    repr(show_bench),
-                    reason)
-                print
-            return
-
-        if reportfile:
-            print 'Creating benchmark: %s (rounds=%i, warp=%i)' % \
-                  (reportfile, rounds, warp)
-            print
-
-        # Create benchmark object
-        bench = Benchmark(reportfile,
-                          verbose=verbose,
-                          timer=timer,
-                          warp=warp,
-                          calibration_runs=calibration_runs)
-        bench.rounds = rounds
-        bench.load_tests(Setup, limitnames=limitnames)
-        try:
-            bench.calibrate()
-            bench.run()
-        except KeyboardInterrupt:
-            print
-            print '*** KeyboardInterrupt -- Aborting'
-            print
-            return
-        bench.print_header()
-        if compare_to:
-            bench.print_comparison(compare_to,
-                                   hidenoise=hidenoise,
-                                   limitnames=limitnames)
-        else:
-            bench.print_benchmark(hidenoise=hidenoise,
-                                  limitnames=limitnames)
-
-        # Ring bell
-        sys.stderr.write('\007')
-
-        if reportfile:
-            try:
-                f = open(reportfile,'wb')
-                bench.name = reportfile
-                pickle.dump(bench,f)
-                f.close()
-            except IOError:
-                print '* Error opening/writing reportfile'
-
-if __name__ == '__main__':
-    PyBenchCmdline()
diff --git a/Tools/pybench/pybench-2.0/systimes.py b/Tools/pybench/pybench-2.0/systimes.py
deleted file mode 100644
index bf07e36..0000000
--- a/Tools/pybench/pybench-2.0/systimes.py
+++ /dev/null
@@ -1,211 +0,0 @@
-#!/usr/bin/env python
-
-""" systimes() user and system timer implementations for use by
-    pybench.
-
-    This module implements various different strategies for measuring
-    performance timings. It tries to choose the best available method
-    based on the platforma and available tools.
-
-    On Windows, it is recommended to have the Mark Hammond win32
-    package installed. Alternatively, the Thomas Heller ctypes
-    packages can also be used.
-
-    On Unix systems, the standard resource module provides the highest
-    resolution timings. Unfortunately, it is not available on all Unix
-    platforms.
-
-    If no supported timing methods based on process time can be found,
-    the module reverts to the highest resolution wall-clock timer
-    instead. The system time part will then always be 0.0.
-
-    The module exports one public API:
-
-    def systimes():
-
-        Return the current timer values for measuring user and system
-        time as tuple of seconds (user_time, system_time).
-
-    Copyright (c) 2006, Marc-Andre Lemburg (mal@egenix.com). See the
-    documentation for further information on copyrights, or contact
-    the author. All Rights Reserved.
-
-"""
-import time, sys, struct
-
-#
-# Note: Please keep this module compatible to Python 1.5.2.
-#
-# TODOs:
-#
-# * Add ctypes wrapper for new clock_gettime() real-time POSIX APIs;
-#   these will then provide nano-second resolution where available.
-#
-# * Add a function that returns the resolution of systimes()
-#   values, ie. systimesres().
-#
-
-### Choose an implementation
-
-SYSTIMES_IMPLEMENTATION = None
-USE_CTYPES_GETPROCESSTIMES = 'cytpes GetProcessTimes() wrapper'
-USE_WIN32PROCESS_GETPROCESSTIMES = 'win32process.GetProcessTimes()'
-USE_RESOURCE_GETRUSAGE = 'resource.getrusage()'
-USE_PROCESS_TIME_CLOCK = 'time.clock() (process time)'
-USE_WALL_TIME_CLOCK = 'time.clock() (wall-clock)'
-USE_WALL_TIME_TIME = 'time.time() (wall-clock)'
-
-if sys.platform[:3] == 'win':
-    # Windows platform
-    try:
-        import win32process
-    except ImportError:
-        try:
-            import ctypes
-        except ImportError:
-            # Use the wall-clock implementation time.clock(), since this
-            # is the highest resolution clock available on Windows
-            SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_CLOCK
-        else:
-            SYSTIMES_IMPLEMENTATION = USE_CTYPES_GETPROCESSTIMES
-    else:
-        SYSTIMES_IMPLEMENTATION = USE_WIN32PROCESS_GETPROCESSTIMES
-else:
-    # All other platforms
-    try:
-        import resource
-    except ImportError:
-        pass
-    else:
-        SYSTIMES_IMPLEMENTATION = USE_RESOURCE_GETRUSAGE
-
-# Fall-back solution
-if SYSTIMES_IMPLEMENTATION is None:
-    # Check whether we can use time.clock() as approximation
-    # for systimes()
-    start = time.clock()
-    time.sleep(0.1)
-    stop = time.clock()
-    if stop - start < 0.001:
-        # Looks like time.clock() is usable (and measures process
-        # time)
-        SYSTIMES_IMPLEMENTATION = USE_PROCESS_TIME_CLOCK
-    else:
-        # Use wall-clock implementation time.time() since this provides
-        # the highest resolution clock on most systems
-        SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_TIME
-
-### Implementations
-
-def getrusage_systimes():
-    return resource.getrusage(resource.RUSAGE_SELF)[:2]
-
-def process_time_clock_systimes():
-    return (time.clock(), 0.0)
-
-def wall_clock_clock_systimes():
-    return (time.clock(), 0.0)
-
-def wall_clock_time_systimes():
-    return (time.time(), 0.0)
-
-# Number of clock ticks per second for the values returned
-# by GetProcessTimes() on Windows.
-#
-# Note: Ticks returned by GetProcessTimes() are 100ns intervals on
-# Windows XP. However, the process times are only updated with every
-# clock tick and the frequency of these is somewhat lower: depending
-# on the OS version between 10ms and 15ms. Even worse, the process
-# time seems to be allocated to process currently running when the
-# clock interrupt arrives, ie. it is possible that the current time
-# slice gets accounted to a different process.
-
-WIN32_PROCESS_TIMES_TICKS_PER_SECOND = 1e7
-
-def win32process_getprocesstimes_systimes():
-    d = win32process.GetProcessTimes(win32process.GetCurrentProcess())
-    return (d['UserTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
-            d['KernelTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
-
-def ctypes_getprocesstimes_systimes():
-    creationtime = ctypes.c_ulonglong()
-    exittime = ctypes.c_ulonglong()
-    kerneltime = ctypes.c_ulonglong()
-    usertime = ctypes.c_ulonglong()
-    rc = ctypes.windll.kernel32.GetProcessTimes(
-        ctypes.windll.kernel32.GetCurrentProcess(),
-        ctypes.byref(creationtime),
-        ctypes.byref(exittime),
-        ctypes.byref(kerneltime),
-        ctypes.byref(usertime))
-    if not rc:
-        raise TypeError('GetProcessTimes() returned an error')
-    return (usertime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
-            kerneltime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
-
-# Select the default for the systimes() function
-
-if SYSTIMES_IMPLEMENTATION is USE_RESOURCE_GETRUSAGE:
-    systimes = getrusage_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_PROCESS_TIME_CLOCK:
-    systimes = process_time_clock_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_CLOCK:
-    systimes = wall_clock_clock_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_TIME:
-    systimes = wall_clock_time_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_WIN32PROCESS_GETPROCESSTIMES:
-    systimes = win32process_getprocesstimes_systimes
-
-elif SYSTIMES_IMPLEMENTATION is USE_CTYPES_GETPROCESSTIMES:
-    systimes = ctypes_getprocesstimes_systimes
-
-else:
-    raise TypeError('no suitable systimes() implementation found')
-
-def processtime():
-
-    """ Return the total time spent on the process.
-
-        This is the sum of user and system time as returned by
-        systimes().
-
-    """
-    user, system = systimes()
-    return user + system
-
-### Testing
-
-def some_workload():
-    x = 0L
-    for i in xrange(10000000L):
-        x = x + 1L
-
-def test_workload():
-    print 'Testing systimes() under load conditions'
-    t0 = systimes()
-    some_workload()
-    t1 = systimes()
-    print 'before:', t0
-    print 'after:', t1
-    print 'differences:', (t1[0] - t0[0], t1[1] - t0[1])
-    print
-
-def test_idle():
-    print 'Testing systimes() under idle conditions'
-    t0 = systimes()
-    time.sleep(1)
-    t1 = systimes()
-    print 'before:', t0
-    print 'after:', t1
-    print 'differences:', (t1[0] - t0[0], t1[1] - t0[1])
-    print
-
-if __name__ == '__main__':
-    print 'Using %s as timer' % SYSTIMES_IMPLEMENTATION
-    print
-    test_workload()
-    test_idle()