diff options
Diffstat (limited to 'testsuite/tests/codeGen/should_compile')
19 files changed, 913 insertions, 0 deletions
diff --git a/testsuite/tests/codeGen/should_compile/1916.hs b/testsuite/tests/codeGen/should_compile/1916.hs new file mode 100644 index 0000000000..7210aaf41c --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/1916.hs @@ -0,0 +1,3 @@ +module Bug (tst) where +tst :: Float -> Bool +tst x = truncate x > (0::Int) diff --git a/testsuite/tests/codeGen/should_compile/2388.hs b/testsuite/tests/codeGen/should_compile/2388.hs new file mode 100644 index 0000000000..f3364f5b6e --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/2388.hs @@ -0,0 +1,14 @@ +module Q where + +import Data.Bits +import Data.Word +import Data.Int + +test1 :: Word32 -> Char +test1 w | w .&. 0x80000000 /= 0 = 'a' +test1 _ = 'b' + +-- this should use a testq instruction on x86_64 +test2 :: Int64 -> Char +test2 w | w .&. (-3) /= 0 = 'a' +test2 _ = 'b' diff --git a/testsuite/tests/codeGen/should_compile/2578.hs b/testsuite/tests/codeGen/should_compile/2578.hs new file mode 100644 index 0000000000..c851b54f88 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/2578.hs @@ -0,0 +1,17 @@ + +{-# LANGUAGE EmptyDataDecls #-} + +-- This used to give warnings: +-- ld: atom sorting error for _Main_MyType_closure_tbl and _Main_MyType2_closure_tbl in q.o +-- ld: atom sorting error for _Main_MyType_closure_tbl and _Main_MyType2_closure_tbl in q.o +-- ld: atom sorting error for _Main_MyType_closure_tbl and _Main_MyType2_closure_tbl in q.o +-- when compiling on OS X (trac #2578). + +module Main (main) where + +data MyType +data MyType2 + +main :: IO () +main = print () + diff --git a/testsuite/tests/codeGen/should_compile/3132.hs b/testsuite/tests/codeGen/should_compile/3132.hs new file mode 100644 index 0000000000..c6aa2579e9 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/3132.hs @@ -0,0 +1,6 @@ +module Spring where + +import Data.Array.Unboxed + +step :: UArray Int Double -> [Double] +step y = [y!1 + y!0] diff --git a/testsuite/tests/codeGen/should_compile/3579.hs b/testsuite/tests/codeGen/should_compile/3579.hs new file mode 100644 index 0000000000..29711e147b --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/3579.hs @@ -0,0 +1,7 @@ +module Bug where + +compose :: [a -> a] -> a -> a +compose = foldr (.) id + +class Compose a where + compose1 :: a -> a -> a diff --git a/testsuite/tests/codeGen/should_compile/Makefile b/testsuite/tests/codeGen/should_compile/Makefile new file mode 100644 index 0000000000..ff43099198 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/Makefile @@ -0,0 +1,7 @@ +TOP=../../.. +include $(TOP)/mk/boilerplate.mk +include $(TOP)/mk/test.mk + +2578: + '$(TEST_HC)' $(TEST_HC_OPTS) --make 2578 -fforce-recomp -v0 + diff --git a/testsuite/tests/codeGen/should_compile/T3286.hs b/testsuite/tests/codeGen/should_compile/T3286.hs new file mode 100644 index 0000000000..0cc852db94 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/T3286.hs @@ -0,0 +1,45 @@ + +module T3286 (train) where + +import qualified Data.Map as M +import Data.List (groupBy, foldl') +import Data.Maybe (fromMaybe, fromJust) +import Data.Function (on) +import T3286b + +type Prob = LogFloat + +learn_states :: (Ord state) => [(observation, state)] -> M.Map state Prob +learn_states xs = histogram $ map snd xs + +learn_observations :: (Ord state, Ord observation) => + M.Map state Prob + -> [(observation, state)] + -> M.Map (observation, state) Prob +learn_observations state_prob = M.mapWithKey f . histogram + where f (_, state) prob = prob / (fromJust $ M.lookup state state_prob) + +histogram :: (Ord a) => [a] -> M.Map a Prob +histogram xs = let hist = foldl' undefined M.empty xs in + M.map (/ M.foldrWithKey (\_ a b -> a + b) 0 hist) hist + +train :: (Ord observation, Ord state) => + [(observation, state)] + -> (observation -> [Prob]) +train sample = model + where + states = learn_states sample + state_list = M.keys states + + observations = learn_observations states sample + observation_probs = fromMaybe (fill state_list []) . (flip M.lookup $ + M.fromList $ map (\ (e, xs) -> (e, fill state_list xs)) $ + map (\ xs -> (fst $ head xs, map snd xs)) $ + groupBy ((==) `on` fst) + [(observation, (state, prob)) + | ((observation, state), prob) <- M.toAscList observations]) + + model = observation_probs + + fill :: Eq state => [state] -> [(state, Prob)] -> [Prob] + fill = undefined diff --git a/testsuite/tests/codeGen/should_compile/T3286b.hs b/testsuite/tests/codeGen/should_compile/T3286b.hs new file mode 100644 index 0000000000..f6c1fdbeac --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/T3286b.hs @@ -0,0 +1,15 @@ + +{-# LANGUAGE GeneralizedNewtypeDeriving #-} + +module T3286b (LogFloat) where + +newtype LogFloat = LogFloat Double + deriving (Eq, Ord, Num, Show) + +instance Fractional LogFloat where + (/) (LogFloat x) (LogFloat y) + | x == 1 + && y == 1 = error "(/)" + | otherwise = LogFloat (x-y) + fromRational = LogFloat . fromRational + diff --git a/testsuite/tests/codeGen/should_compile/all.T b/testsuite/tests/codeGen/should_compile/all.T new file mode 100644 index 0000000000..ba29c2a145 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/all.T @@ -0,0 +1,19 @@ +test('cg001', only_compiler_types(['ghc']), compile, ['']) +test('cg002', normal, compile, ['']) +test('cg003', only_ways(['optasm']), compile, ['']) +test('cg004', normal, compile, ['']) +test('cg005', only_ways(['optasm']), compile, ['']) +test('cg006', normal, compile, ['']) +test('cg007', normal, compile, ['']) +test('cg008', normal, compile, ['']) + +test('1916', normal, compile, ['']) +test('2388', normal, compile, ['']) +test('3132', normal, compile, ['-dcmm-lint']) +test('T3286', extra_clean(['T3286b.o','T3286b.hi']), + multimod_compile, ['T3286', '-v0']) +test('3579', normal, compile, ['']) +test('2578', normal, run_command, ['$MAKE -s --no-print-directory 2578']) +# skip llvm on i386 as we don't support fPIC +test('jmp_tbl', if_arch('i386', omit_ways(['llvm', 'optllvm'])), compile, ['-fPIC -O']) +test('massive_array', if_arch('i386', omit_ways(['llvm', 'optllvm'])), compile, ['-fPIC']) diff --git a/testsuite/tests/codeGen/should_compile/cg001.hs b/testsuite/tests/codeGen/should_compile/cg001.hs new file mode 100644 index 0000000000..ad00a8f89c --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg001.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE MagicHash #-} + +module ShouldCompile where + +import GHC.Exts + +data STRef s a = STRef (MutVar# s a) + +-- ghc 4.08 had a problem with returning a MutVar#. + +from :: STRef s a -> MutVar# s a +from (STRef x) = x + +to :: MutVar# s a -> STRef s a +to x = STRef x diff --git a/testsuite/tests/codeGen/should_compile/cg002.hs b/testsuite/tests/codeGen/should_compile/cg002.hs new file mode 100644 index 0000000000..9d655d9d12 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg002.hs @@ -0,0 +1,5 @@ + +module M where +import Data.Char +{-# INLINE f #-} +f = map ord . map chr diff --git a/testsuite/tests/codeGen/should_compile/cg003.hs b/testsuite/tests/codeGen/should_compile/cg003.hs new file mode 100644 index 0000000000..e7cea2e0b3 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg003.hs @@ -0,0 +1,7 @@ +module Test where + +-- !!! caused compiler to generate bogus HC code, fixed in +-- basicTypes/Literal.lhs rev. 1.36. + +f :: Double -> Int +f x = round (x - (-5.0)) diff --git a/testsuite/tests/codeGen/should_compile/cg004.hs b/testsuite/tests/codeGen/should_compile/cg004.hs new file mode 100644 index 0000000000..fb8e3cc413 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg004.hs @@ -0,0 +1,30 @@ +module ShouldCompile where + +-- Killed GHC 6.0 in isCrossDllArg +-- +-- ghc-6.0: panic! (the `impossible' happened, GHC version 6.0): +-- coreSyn/CoreUtils.lhs:1188: Non-exhaustive patterns in function isCrossDllArg +-- +-- The reason was that newST had the form +-- newST = \ @ v -> GHC.Base.: +-- @ (Environment.Scope v) +-- (case $fScopeOpersScope @ v +-- of tpl_B1 { Environment.:DScopeOpers tpl_B2 tpl_B3 -> +-- tpl_B2 +-- }) +-- (GHC.Base.[] @ (Environment.Scope v)) + +class ScopeOpers s where + emptyScope :: s + op :: s -> s + +data Scope v = NewScope + +instance ScopeOpers (Scope v) where + emptyScope = error "emptyScope" + op = error "op" + +newtype SymbolTable v = SymbolTable [Scope v] + +newST :: SymbolTable v +newST = SymbolTable [emptyScope] diff --git a/testsuite/tests/codeGen/should_compile/cg005.hs b/testsuite/tests/codeGen/should_compile/cg005.hs new file mode 100644 index 0000000000..a25ad4250a --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg005.hs @@ -0,0 +1,20 @@ +module Bug where
+
+import Foreign hiding ( unsafePerformIO )
+import Foreign.ForeignPtr
+import Data.Char
+import System.IO.Unsafe
+
+data PackedString = PS !(ForeignPtr Word8) !Int !Int
+
+(!) :: PackedString -> Int -> Word8
+(PS x s _l) ! i
+ = unsafePerformIO $ withForeignPtr x $ \p -> peekElemOff p (s+i)
+
+w2c :: Word8 -> Char
+w2c = chr . fromIntegral
+
+indexPS :: PackedString -> Int -> Char
+indexPS theps i | i < 0 = error "Negative index in indexPS"
+ | otherwise = w2c $ theps ! i
+
diff --git a/testsuite/tests/codeGen/should_compile/cg006.hs b/testsuite/tests/codeGen/should_compile/cg006.hs new file mode 100644 index 0000000000..494b37937b --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg006.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE MagicHash #-} +module ShouldCompile where + +-- exposed a bug in the NCG in 6.4.2 +import GHC.Base +class Unboxable a where + writeUnboxable :: MutableByteArray# RealWorld -> a -> State# RealWorld -> State# RealWorld + writeUnboxable arr a s = writeInt8Array# arr 0# (getTag 0) s diff --git a/testsuite/tests/codeGen/should_compile/cg007.hs b/testsuite/tests/codeGen/should_compile/cg007.hs new file mode 100644 index 0000000000..5ef739bd47 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg007.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module ShouldCompile where + +import Foreign.C.Types + +{- +During 6.11, this was failing like this: + +In file included from /ghc/includes/Stg.h:207, + + from /tmp/ghc2904_0/ghc2904_0.hc:3:0: +/tmp/ghc2904_0/ghc2904_0.hc: In function `swM_ret': + +/tmp/ghc2904_0/ghc2904_0.hc:22:0: + error: `gamma' undeclared (first use in this function) + +/tmp/ghc2904_0/ghc2904_0.hc:22:0: + error: (Each undeclared identifier is reported only once + +/tmp/ghc2904_0/ghc2904_0.hc:22:0: + error: for each function it appears in.) +-} + +foreign import ccall unsafe "math.h gamma" + gamma :: CDouble -> CDouble + diff --git a/testsuite/tests/codeGen/should_compile/cg008.hs b/testsuite/tests/codeGen/should_compile/cg008.hs new file mode 100644 index 0000000000..10099c1b48 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/cg008.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE MagicHash, BangPatterns #-} +{-# OPTIONS_GHC -O0 #-} + +-- Variant of cgrun066; compilation as a module is different. + +module Cg008 (hashStr) where + +import Foreign.C +import Data.Word +import Foreign.Ptr +import GHC.Exts + +import Control.Exception + +hashStr :: Ptr Word8 -> Int -> Int +hashStr (Ptr a#) (I# len#) = loop 0# 0# + where + loop h n | n GHC.Exts.==# len# = I# h + | otherwise = loop h2 (n GHC.Exts.+# 1#) + where !c = ord# (indexCharOffAddr# a# n) + !h2 = (c GHC.Exts.+# (h GHC.Exts.*# 128#)) `remInt#` 4091# diff --git a/testsuite/tests/codeGen/should_compile/jmp_tbl.hs b/testsuite/tests/codeGen/should_compile/jmp_tbl.hs new file mode 100644 index 0000000000..56904ed7a1 --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/jmp_tbl.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE NamedFieldPuns #-} + +{- +This funny module was reduced from a failing build of stage2 using +the new code generator and the linear register allocator, with this bug: + +"inplace/bin/ghc-stage1" -fPIC -dynamic -H32m -O -Wall -H64m -O0 -package-name ghc-7.1.20110414 -hide-all-packages -i -icompiler/basicTypes -icompiler/cmm -icompiler/codeGen -icompiler/coreSyn -icompiler/deSugar -icompiler/ghci -icompiler/hsSyn -icompiler/iface -icompiler/llvmGen -icompiler/main -icompiler/nativeGen -icompiler/parser -icompiler/prelude -icompiler/profiling -icompiler/rename -icompiler/simplCore -icompiler/simplStg -icompiler/specialise -icompiler/stgSyn -icompiler/stranal -icompiler/typecheck -icompiler/types -icompiler/utils -icompiler/vectorise -icompiler/stage2/build -icompiler/stage2/build/autogen -Icompiler/stage2/build -Icompiler/stage2/build/autogen -Icompiler/../libffi/build/include -Icompiler/stage2 -Icompiler/../libraries/base/cbits -Icompiler/../libraries/base/include -Icompiler/. -Icompiler/parser -Icompiler/utils -optP-DGHCI -optP-include -optPcompiler/stage2/build/autogen/cabal_macros.h -package Cabal-1.11.0 -package array-0.3.0.2 -package base-4.3.1.0 -package bin-package-db-0.0.0.0 -package bytestring-0.9.1.10 -package containers-0.4.0.0 -package directory-1.1.0.0 -package filepath-1.2.0.0 -package hoopl-3.8.7.0 -package hpc-0.5.0.6 -package old-time-1.0.0.6 -package process-1.0.1.4 -package template-haskell-2.5.0.0 -package unix-2.4.1.0 -Wall -fno-warn-name-shadowing -fno-warn-orphans -XHaskell98 -XNondecreasingIndentation -XCPP -XMagicHash -XUnboxedTuples -XPatternGuards -XForeignFunctionInterface -XEmptyDataDecls -XTypeSynonymInstances -XMultiParamTypeClasses -XFlexibleInstances -XRank2Types -XScopedTypeVariables -XDeriveDataTypeable -DGHCI_TABLES_NEXT_TO_CODE -DSTAGE=2 -O2 -O -DGHC_DEFAULT_NEW_CODEGEN -no-user-package-conf -rtsopts -odir compiler/stage2/build -hidir compiler/stage2/build -stubdir compiler/stage2/build -hisuf dyn_hi -osuf dyn_o -hcsuf dyn_hc -c compiler/main/DriverPipeline.hs -o compiler/stage2/build/DriverPipeline.dyn_o -fforce-recomp -dno-debug-output -fno-warn-unused-binds + +ghc-stage1: panic! (the 'impossible' happened) + (GHC version 7.1.20110414 for x86_64-unknown-linux): + Cannot patch JMP_TBL + +This panic only appears to show up on x86-64 and with -fPIC. I wasn't +able to get the produced optimized C-- to crash the linear register +allocator. To see the bug, you need some extra patches for the new code +generator, in particular, this set (which can be acquired from the +jmp_tbl_bug tag at <https://github.com/ezyang/ghc>): + + commit 7b275c93df7944f0a9b51034cf1f64e3e70582a5 + Author: Edward Z. Yang <ezyang@mit.edu> + Date: Thu Apr 14 21:20:21 2011 +0100 + + Give manifestSP better information about the actual SP location. + + This patch fixes silliness where the SP pointer is continually + bumped up and down. + + Signed-off-by: Edward Z. Yang <ezyang@mit.edu> + + commit 5b5add4246d3997670ae995f7d2a028db92fff95 + Author: Edward Z. Yang <ezyang@mit.edu> + Date: Wed Apr 13 11:16:36 2011 +0100 + + Generalized assignment rewriting pass. + + This assignment rewriting pass subsumes the previous reload + sinking pass, and also performs basic inlining. + + Signed-off-by: Edward Z. Yang <ezyang@mit.edu> + +The ostensible cause is that the linear register allocator is getting +really unlucky and needs to insert a fixup block after precisely one +jump in a jump table, because the block it jumps to was processed +already. As you can see, actually getting the linear register allocator +into this funk is /very/ difficult. + +-} + +module DriverPipeline (compileFile) where + +import Control.Exception + +data Phase + = Unlit () + | Ccpp + | Cc + | Cobjc + | HCc + | SplitAs + | As + | LlvmOpt + | LlvmLlc + | LlvmMangle + | MergeStub + | StopLn + deriving (Show) + +data PipeState = PipeState { + stop_phase :: Phase, + src_basename :: String, + output_spec :: (), + hsc_env :: Maybe String, + maybe_loc :: Maybe String + } + +newtype CompPipeline a = P { unP :: PipeState -> IO (PipeState, a) } + +instance Monad CompPipeline where + return a = P $ \state -> return (state, a) + P m >>= k = P $ \state -> do (state',a) <- m state + unP (k a) state' + +eqPhase :: Phase -> Phase -> Bool +eqPhase (Unlit _) (Unlit _) = True +eqPhase Ccpp Ccpp = True +eqPhase Cc Cc = True +eqPhase HCc HCc = True +eqPhase SplitAs SplitAs = True +eqPhase As As = True +eqPhase LlvmOpt LlvmOpt = True +eqPhase LlvmLlc LlvmLlc = True +eqPhase LlvmMangle LlvmMangle = True +eqPhase MergeStub MergeStub = True +eqPhase StopLn StopLn = True +eqPhase _ _ = False + +compileFile start_phase state = do + unP (pipeLoop start_phase) state + getOutputFilename undefined undefined undefined undefined undefined undefined + +pipeLoop phase = do + dflags@PipeState{stop_phase} <- getPipeState + io $ evaluate (phase `eqPhase` stop_phase) + runPhase phase dflags + pipeLoop phase + +getOutputFilename :: Phase -> () -> String -> Maybe String -> Phase -> Maybe String -> IO String +getOutputFilename p o b md p' ml + | p' `eqPhase` p, () <- o = undefined + | Just l <- ml = return l + | Just d <- md = return $ d ++ b + | otherwise = undefined + +runPhase p _ | p `eqPhase` Cc || p `eqPhase` Ccpp || p `eqPhase` HCc || p `eqPhase` Cobjc = undefined +runPhase LlvmMangle _ = undefined +runPhase SplitAs _ = undefined +runPhase LlvmOpt _ = undefined +runPhase LlvmLlc dflags = phaseOutputFilename >> io (evaluate dflags) >> return undefined +runPhase MergeStub _ = phaseOutputFilename >> undefined +runPhase other _ = io (evaluate (show other)) >> undefined + +phaseOutputFilename :: CompPipeline () +phaseOutputFilename = do + PipeState{stop_phase, src_basename, output_spec, maybe_loc, hsc_env} <- getPipeState + io $ getOutputFilename stop_phase output_spec src_basename hsc_env StopLn maybe_loc + +getPipeState = P $ \state -> return (state, state) +io m = P $ \state -> do a <- m; return (state, ()) diff --git a/testsuite/tests/codeGen/should_compile/massive_array.hs b/testsuite/tests/codeGen/should_compile/massive_array.hs new file mode 100644 index 0000000000..a9db12bc4c --- /dev/null +++ b/testsuite/tests/codeGen/should_compile/massive_array.hs @@ -0,0 +1,520 @@ +{-# OPTIONS_GHC -fno-ignore-interface-pragmas -fasm #-} + +-- This test breaks the linear register allocator when compiled the +-- flags -fnew-codegen, -fPIC and -dynamic, running out of stack +-- slots. You actually don't need 500 elements; 32-bit fails +-- with only about 260 or so. Works for stage1 too! It's a bit touchy +-- about optimization flags; if you specify -O or -O0 in OPTIONS_GHC +-- the bug goes away. Shows up in GHC 7.0.3. +-- +-- The -fno-ignore-interface-pragmas flag is pretty important! (Though I +-- don't quite know why yet.) Gigantic arrays like this show up in +-- generated code, in particular Parser.hs from Happy in GHC. + +module MassiveArray where + +import Data.Array + +f = array (0, 499) + $ [ + (0, 0), + (1, 1), + (2, 2), + (3, 3), + (4, 4), + (5, 5), + (6, 6), + (7, 7), + (8, 8), + (9, 9), + (10, 10), + (11, 11), + (12, 12), + (13, 13), + (14, 14), + (15, 15), + (16, 16), + (17, 17), + (18, 18), + (19, 19), + (20, 20), + (21, 21), + (22, 22), + (23, 23), + (24, 24), + (25, 25), + (26, 26), + (27, 27), + (28, 28), + (29, 29), + (30, 30), + (31, 31), + (32, 32), + (33, 33), + (34, 34), + (35, 35), + (36, 36), + (37, 37), + (38, 38), + (39, 39), + (40, 40), + (41, 41), + (42, 42), + (43, 43), + (44, 44), + (45, 45), + (46, 46), + (47, 47), + (48, 48), + (49, 49), + (50, 50), + (51, 51), + (52, 52), + (53, 53), + (54, 54), + (55, 55), + (56, 56), + (57, 57), + (58, 58), + (59, 59), + (60, 60), + (61, 61), + (62, 62), + (63, 63), + (64, 64), + (65, 65), + (66, 66), + (67, 67), + (68, 68), + (69, 69), + (70, 70), + (71, 71), + (72, 72), + (73, 73), + (74, 74), + (75, 75), + (76, 76), + (77, 77), + (78, 78), + (79, 79), + (80, 80), + (81, 81), + (82, 82), + (83, 83), + (84, 84), + (85, 85), + (86, 86), + (87, 87), + (88, 88), + (89, 89), + (90, 90), + (91, 91), + (92, 92), + (93, 93), + (94, 94), + (95, 95), + (96, 96), + (97, 97), + (98, 98), + (99, 99), + (100, 100), + (101, 101), + (102, 102), + (103, 103), + (104, 104), + (105, 105), + (106, 106), + (107, 107), + (108, 108), + (109, 109), + (110, 110), + (111, 111), + (112, 112), + (113, 113), + (114, 114), + (115, 115), + (116, 116), + (117, 117), + (118, 118), + (119, 119), + (120, 120), + (121, 121), + (122, 122), + (123, 123), + (124, 124), + (125, 125), + (126, 126), + (127, 127), + (128, 128), + (129, 129), + (130, 130), + (131, 131), + (132, 132), + (133, 133), + (134, 134), + (135, 135), + (136, 136), + (137, 137), + (138, 138), + (139, 139), + (140, 140), + (141, 141), + (142, 142), + (143, 143), + (144, 144), + (145, 145), + (146, 146), + (147, 147), + (148, 148), + (149, 149), + (150, 150), + (151, 151), + (152, 152), + (153, 153), + (154, 154), + (155, 155), + (156, 156), + (157, 157), + (158, 158), + (159, 159), + (160, 160), + (161, 161), + (162, 162), + (163, 163), + (164, 164), + (165, 165), + (166, 166), + (167, 167), + (168, 168), + (169, 169), + (170, 170), + (171, 171), + (172, 172), + (173, 173), + (174, 174), + (175, 175), + (176, 176), + (177, 177), + (178, 178), + (179, 179), + (180, 180), + (181, 181), + (182, 182), + (183, 183), + (184, 184), + (185, 185), + (186, 186), + (187, 187), + (188, 188), + (189, 189), + (190, 190), + (191, 191), + (192, 192), + (193, 193), + (194, 194), + (195, 195), + (196, 196), + (197, 197), + (198, 198), + (199, 199), + (200, 200), + (201, 201), + (202, 202), + (203, 203), + (204, 204), + (205, 205), + (206, 206), + (207, 207), + (208, 208), + (209, 209), + (210, 210), + (211, 211), + (212, 212), + (213, 213), + (214, 214), + (215, 215), + (216, 216), + (217, 217), + (218, 218), + (219, 219), + (220, 220), + (221, 221), + (222, 222), + (223, 223), + (224, 224), + (225, 225), + (226, 226), + (227, 227), + (228, 228), + (229, 229), + (230, 230), + (231, 231), + (232, 232), + (233, 233), + (234, 234), + (235, 235), + (236, 236), + (237, 237), + (238, 238), + (239, 239), + (240, 240), + (241, 241), + (242, 242), + (243, 243), + (244, 244), + (245, 245), + (246, 246), + (247, 247), + (248, 248), + (249, 249), + (250, 250), + (251, 251), + (252, 252), + (253, 253), + (254, 254), + (255, 255), + (256, 256), + (257, 257), + (258, 258), + (259, 259), + (260, 260), + (261, 261), + (262, 262), + (263, 263), + (264, 264), + (265, 265), + (266, 266), + (267, 267), + (268, 268), + (269, 269), + (270, 270), + (271, 271), + (272, 272), + (273, 273), + (274, 274), + (275, 275), + (276, 276), + (277, 277), + (278, 278), + (279, 279), + (280, 280), + (281, 281), + (282, 282), + (283, 283), + (284, 284), + (285, 285), + (286, 286), + (287, 287), + (288, 288), + (289, 289), + (290, 290), + (291, 291), + (292, 292), + (293, 293), + (294, 294), + (295, 295), + (296, 296), + (297, 297), + (298, 298), + (299, 299), + (300, 300), + (301, 301), + (302, 302), + (303, 303), + (304, 304), + (305, 305), + (306, 306), + (307, 307), + (308, 308), + (309, 309), + (310, 310), + (311, 311), + (312, 312), + (313, 313), + (314, 314), + (315, 315), + (316, 316), + (317, 317), + (318, 318), + (319, 319), + (320, 320), + (321, 321), + (322, 322), + (323, 323), + (324, 324), + (325, 325), + (326, 326), + (327, 327), + (328, 328), + (329, 329), + (330, 330), + (331, 331), + (332, 332), + (333, 333), + (334, 334), + (335, 335), + (336, 336), + (337, 337), + (338, 338), + (339, 339), + (340, 340), + (341, 341), + (342, 342), + (343, 343), + (344, 344), + (345, 345), + (346, 346), + (347, 347), + (348, 348), + (349, 349), + (350, 350), + (351, 351), + (352, 352), + (353, 353), + (354, 354), + (355, 355), + (356, 356), + (357, 357), + (358, 358), + (359, 359), + (360, 360), + (361, 361), + (362, 362), + (363, 363), + (364, 364), + (365, 365), + (366, 366), + (367, 367), + (368, 368), + (369, 369), + (370, 370), + (371, 371), + (372, 372), + (373, 373), + (374, 374), + (375, 375), + (376, 376), + (377, 377), + (378, 378), + (379, 379), + (380, 380), + (381, 381), + (382, 382), + (383, 383), + (384, 384), + (385, 385), + (386, 386), + (387, 387), + (388, 388), + (389, 389), + (390, 390), + (391, 391), + (392, 392), + (393, 393), + (394, 394), + (395, 395), + (396, 396), + (397, 397), + (398, 398), + (399, 399), + (400, 400), + (401, 401), + (402, 402), + (403, 403), + (404, 404), + (405, 405), + (406, 406), + (407, 407), + (408, 408), + (409, 409), + (410, 410), + (411, 411), + (412, 412), + (413, 413), + (414, 414), + (415, 415), + (416, 416), + (417, 417), + (418, 418), + (419, 419), + (420, 420), + (421, 421), + (422, 422), + (423, 423), + (424, 424), + (425, 425), + (426, 426), + (427, 427), + (428, 428), + (429, 429), + (430, 430), + (431, 431), + (432, 432), + (433, 433), + (434, 434), + (435, 435), + (436, 436), + (437, 437), + (438, 438), + (439, 439), + (440, 440), + (441, 441), + (442, 442), + (443, 443), + (444, 444), + (445, 445), + (446, 446), + (447, 447), + (448, 448), + (449, 449), + (450, 450), + (451, 451), + (452, 452), + (453, 453), + (454, 454), + (455, 455), + (456, 456), + (457, 457), + (458, 458), + (459, 459), + (460, 460), + (461, 461), + (462, 462), + (463, 463), + (464, 464), + (465, 465), + (466, 466), + (467, 467), + (468, 468), + (469, 469), + (470, 470), + (471, 471), + (472, 472), + (473, 473), + (474, 474), + (475, 475), + (476, 476), + (477, 477), + (478, 478), + (479, 479), + (480, 480), + (481, 481), + (482, 482), + (483, 483), + (484, 484), + (485, 485), + (486, 486), + (487, 487), + (488, 488), + (489, 489), + (490, 490), + (491, 491), + (492, 492), + (493, 493), + (494, 494), + (495, 495), + (496, 496), + (497, 497), + (498, 498), + (499, 499) + ] |