Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

import sys 

 

try: 

    reversed = reversed 

except NameError: 

    def reversed(sequence): 

        """reversed(sequence) -> reverse iterator over values of the sequence 

 

        Return a reverse iterator 

        """ 

        if hasattr(sequence, '__reversed__'): 

            return sequence.__reversed__() 

        if not hasattr(sequence, '__getitem__'): 

            raise TypeError("argument to reversed() must be a sequence") 

        return reversed_iterator(sequence) 

 

    class reversed_iterator(object): 

 

        def __init__(self, seq): 

            self.seq = seq 

            self.remaining = len(seq) 

 

        def __iter__(self): 

            return self 

 

        def next(self): 

            i = self.remaining 

            if i > 0: 

                i -= 1 

                item = self.seq[i] 

                self.remaining = i 

                return item 

            raise StopIteration 

 

        def __length_hint__(self): 

            return self.remaining 

 

try: 

    any = any 

except NameError: 

    def any(iterable): 

        for x in iterable: 

            if x: 

                return True 

        return False 

 

try: 

    all = all 

except NameError: 

    def all(iterable): 

        for x in iterable: 

            if not x: 

                return False 

        return True 

 

try: 

    sorted = sorted 

except NameError: 

    builtin_cmp = cmp # need to use cmp as keyword arg 

 

    def sorted(iterable, cmp=None, key=None, reverse=0): 

        use_cmp = None 

        if key is not None: 

            if cmp is None: 

                def use_cmp(x, y): 

                    return builtin_cmp(x[0], y[0]) 

            else: 

                def use_cmp(x, y): 

                    return cmp(x[0], y[0]) 

            l = [(key(element), element) for element in iterable] 

        else: 

            if cmp is not None: 

                use_cmp = cmp 

            l = list(iterable) 

        if use_cmp is not None: 

            l.sort(use_cmp) 

        else: 

            l.sort() 

        if reverse: 

            l.reverse() 

        if key is not None: 

            return [element for (_, element) in l] 

        return l 

 

try: 

    set, frozenset = set, frozenset 

except NameError: 

    from sets import set, frozenset 

 

# pass through 

enumerate = enumerate 

 

try: 

    BaseException = BaseException 

except NameError: 

    BaseException = Exception 

 

try: 

    GeneratorExit = GeneratorExit 

except NameError: 

    class GeneratorExit(Exception): 

        """ This exception is never raised, it is there to make it possible to 

        write code compatible with CPython 2.5 even in lower CPython 

        versions.""" 

        pass 

    GeneratorExit.__module__ = 'exceptions' 

 

_sysex = (KeyboardInterrupt, SystemExit, MemoryError, GeneratorExit) 

 

try: 

    callable = callable 

except NameError: 

    def callable(obj): 

        return hasattr(obj, "__call__") 

 

117if sys.version_info >= (3, 0): 

    exec ("print_ = print ; exec_=exec") 

    import builtins 

 

    # some backward compatibility helpers 

    _basestring = str 

    def _totext(obj, encoding=None, errors=None): 

        if isinstance(obj, bytes): 

            if errors is None: 

                obj = obj.decode(encoding) 

            else: 

                obj = obj.decode(encoding, errors) 

        elif not isinstance(obj, str): 

            obj = str(obj) 

        return obj 

 

    def _isbytes(x): 

        return isinstance(x, bytes) 

    def _istext(x): 

        return isinstance(x, str) 

 

    text = str 

    bytes = bytes 

 

 

    def _getimself(function): 

        return getattr(function, '__self__', None) 

 

    def _getfuncdict(function): 

        return getattr(function, "__dict__", None) 

 

    def _getcode(function): 

        return getattr(function, "__code__", None) 

 

    def execfile(fn, globs=None, locs=None): 

        if globs is None: 

            back = sys._getframe(1) 

            globs = back.f_globals 

            locs = back.f_locals 

            del back 

        elif locs is None: 

            locs = globs 

        fp = open(fn, "r") 

        try: 

            source = fp.read() 

        finally: 

            fp.close() 

        co = compile(source, fn, "exec", dont_inherit=True) 

        exec_(co, globs, locs) 

 

else: 

    import __builtin__ as builtins 

    _totext = unicode 

    _basestring = basestring 

    text = unicode 

    bytes = str 

    execfile = execfile 

    callable = callable 

    def _isbytes(x): 

        return isinstance(x, str) 

    def _istext(x): 

        return isinstance(x, unicode) 

 

    def _getimself(function): 

        return getattr(function, 'im_self', None) 

 

    def _getfuncdict(function): 

        return getattr(function, "__dict__", None) 

 

    def _getcode(function): 

        try: 

            return getattr(function, "__code__") 

        except AttributeError: 

            return getattr(function, "func_code", None) 

 

    def print_(*args, **kwargs): 

        """ minimal backport of py3k print statement. """ 

        sep = ' ' 

        if 'sep' in kwargs: 

            sep = kwargs.pop('sep') 

        end = '\n' 

        if 'end' in kwargs: 

            end = kwargs.pop('end') 

        file = 'file' in kwargs and kwargs.pop('file') or sys.stdout 

        if kwargs: 

            args = ", ".join([str(x) for x in kwargs]) 

            raise TypeError("invalid keyword arguments: %s" % args) 

        at_start = True 

        for x in args: 

            if not at_start: 

                file.write(sep) 

            file.write(str(x)) 

            at_start = False 

        file.write(end) 

 

    def exec_(obj, globals=None, locals=None): 

        """ minimal backport of py3k exec statement. """ 

        __tracebackhide__ = True 

215        if globals is None: 

            frame = sys._getframe(1) 

            globals = frame.f_globals 

            if locals is None: 

                locals = frame.f_locals 

221        elif locals is None: 

            locals = globals 

        exec2(obj, globals, locals) 

 

224if sys.version_info >= (3, 0): 

    def _reraise(cls, val, tb): 

        __tracebackhide__ = True 

        assert hasattr(val, '__traceback__') 

        raise cls.with_traceback(val, tb) 

else: 

    exec (""" 

def _reraise(cls, val, tb): 

    __tracebackhide__ = True 

    raise cls, val, tb 

def exec2(obj, globals, locals): 

    __tracebackhide__ = True 

    exec obj in globals, locals 

""") 

 

def _tryimport(*names): 

    """ return the first successfully imported module. """ 

    assert names 

248    for name in names: 

        try: 

            __import__(name) 

        except ImportError: 

            excinfo = sys.exc_info() 

        else: 

            return sys.modules[name] 

    _reraise(*excinfo)