{-

instances:

(Num Int, (inst__Prelude_Num_Int, []))

(Num Integer, (inst__Prelude_Num_Integer, []))

(Num Rational, (inst__Prelude_Num_Rational, []))

(Num Double, (inst__Prelude_Num_Double, []))

(Eq Int, (inst__Prelude_Eq_Int, []))

(Ord Int, (inst__Prelude_Ord_Int, []))

(Enum Int, (inst__Prelude_Enum_Int, []))

(Eq Char, (inst__Prelude_Eq_Char, []))

(Eq Integer, (inst__Prelude_Eq_Integer, []))

(Eq Rational, (inst__Prelude_Eq_Rational, []))

(Eq Double, (inst__Prelude_Eq_Double, []))

(Ord Char, (inst__Prelude_Ord_Char, []))

(Ord Integer, (inst__Prelude_Ord_Integer, []))

(Ord Rational, (inst__Prelude_Ord_Rational, []))

(Ord Double, (inst__Prelude_Ord_Double, []))

(Show Int, (inst__Prelude_Show_Int, []))

(Show Char, (inst__Prelude_Show_Char, []))

(Show Integer, (inst__Prelude_Show_Integer, []))

(Show Rational, (inst__Prelude_Show_Rational, []))

(Show Double, (inst__Prelude_Show_Double, []))

(Fractional Rational, (inst__Prelude_Fractional_Rational, []))

(Fractional Double, (inst__Prelude_Fractional_Double, []))

(Eq Bool, (derived__Prelude_Eq_Bool, []))

(Ord Bool, (derived__Prelude_Ord_Bool, []))

(Show Bool, (derived__Prelude_Show_Bool, []))

(Eq Ordering, (derived__Prelude_Eq_Ordering, []))

(Ord Ordering, (derived__Prelude_Ord_Ordering, []))

(Show Ordering, (derived__Prelude_Show_Ordering, []))

(Eq [a], (derived__Prelude_Eq_34_65, [Eq a]))

(Ord [a], (derived__Prelude_Ord_34_69, [Ord a]))

(Show [a], (derived__Prelude_Show_34_59, [Show a]))

(Eq (), (derived__Prelude_Eq_184_27, []))

(Ord (), (derived__Prelude_Ord_184_31, []))

(Show (), (derived__Prelude_Show_184_36, []))

(Eq (a, b), (derived__Prelude_Eq_188_20, [Eq a,

Eq b]))

(Ord (a, b), (derived__Prelude_Ord_188_24, [Ord a,

Ord b]))

(Show (a, b), (derived__Prelude_Show_188_14, [Show a,

Show b]))

(Eq (a, b, c), (derived__Prelude_Eq_192_20, [Eq a,

Eq b, Eq c]))

(Ord (a, b, c), (derived__Prelude_Ord_192_24, [Ord a,

Ord b, Ord c]))

(Show (a, b,

c), (derived__Prelude_Show_192_14, [Show a, Show b,

Show c]))

(Eq (a, b, c, d), (derived__Prelude_Eq_196_20, [Eq a,

Eq b, Eq c, Eq d]))

(Ord (a, b, c,

d), (derived__Prelude_Ord_196_24, [Ord a, Ord b,

Ord c, Ord d]))

(Show (a, b, c,

d), (derived__Prelude_Show_196_14, [Show a, Show b,

Show c, Show d]))

(Show (Btree a), (derived__Prelude_Show_Btree, [Show a]))

types:

() :: (*, data)

(,) :: (*->*->*, data)

Prelude.(,,) :: (*->*->*->*, data)

Prelude.(,,,) :: (*->*->*->*->*, data)

((->)) :: (*->*->*, data)

Bool :: (*, data)

Bounded ::

(*->Pred, class _ a

where

minBound :: a

maxBound :: a)

Btree :: (*->*, data)

Char :: (*, data)

Double :: (*, data)

Enum ::

(*->Pred, class _ a

where

succ :: a -> a

pred :: a -> a

toEnum :: Int -> a

fromEnum :: a -> Int

enumFrom :: a -> [a]

enumFromThen :: a -> a -> [a]

enumFromTo :: a -> a -> [a]

enumFromThenTo :: a -> a -> a -> [a])

Eq ::

(*->Pred, class _ a

where

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool)

Fractional ::

(*->Pred, class Num a => _ a

where

(/) :: a -> a -> a

recip :: a -> a

fromRational :: Rational -> a)

Int :: (*, data)

Integer :: (*, data)

Integral ::

(*->Pred, class (Real a, Enum a) => _ a

where

quot :: a -> a -> a

rem :: a -> a -> a

div :: a -> a -> a

mod :: a -> a -> a

quotRem :: a -> a -> (a, a)

divMod :: a -> a -> (a, a)

toInteger :: a -> Integer)

Num ::

(*->Pred, class (Eq a, Show a) => _ a

where

(+) :: a -> a -> a

(-) :: a -> a -> a

(*) :: a -> a -> a

negate :: a -> a

abs :: a -> a

signum :: a -> a

fromInteger :: Integer -> a)

Ord ::

(*->Pred, class Eq a => _ a

where

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool

(<=) :: a -> a -> Bool

(>=) :: a -> a -> Bool

(>) :: a -> a -> Bool

max :: a -> a -> a

min :: a -> a -> a)

Ordering :: (*, data)

Rational :: (*, data)

Real ::

(*->Pred, class (Num a, Ord a) => _ a

where

toRational :: a -> Rational)

RealFrac ::

(*->Pred, class (Real a, Fractional a) => _ a

where

properFraction ::

forall a . (Integral a) => a -> (a, a)

truncate :: forall a . (Integral a) => a -> a

round :: forall a . (Integral a) => a -> a

ceiling :: forall a . (Integral a) => a -> a

floor :: forall a . (Integral a) => a -> a)

Show ::

(*->Pred, class _ a

where

showsPrec :: Int -> a -> ShowS

show :: a -> String

showList :: [a] -> ShowS)

ShowS :: (*, type _ = String -> String)

String :: (*, type _ = String)

[] :: (*->*, data)

values:

($--*) :: forall a . (Num a) => a -> a -> a

($--+) :: forall a . (Num a) => a -> a -> a

($---) :: forall a . (Num a) => a -> a -> a

($--/) :: forall a . (Fractional a) => a -> a -> a

($--/=) :: forall a . (Eq a) => a -> a -> Bool

($--<) :: forall a . (Ord a) => a -> a -> Bool

($--<=) :: forall a . (Ord a) => a -> a -> Bool

($--==) :: forall a . (Eq a) => a -> a -> Bool

($-->) :: forall a . (Ord a) => a -> a -> Bool

($-->=) :: forall a . (Ord a) => a -> a -> Bool

(&&) :: Bool -> Bool -> Bool

(*) :: forall a . (Num a) => a -> a -> a

(+) :: forall a . (Num a) => a -> a -> a

(++) :: forall a . [a] -> [a] -> [a]

(-) :: forall a . (Num a) => a -> a -> a

(.) :: forall a b c . (a -> b) -> (c -> a) -> c -> b

(/) :: forall a . (Fractional a) => a -> a -> a

(/=) :: forall a . (Eq a) => a -> a -> Bool

(<) :: forall a . (Ord a) => a -> a -> Bool

(<=) :: forall a . (Ord a) => a -> a -> Bool

(==) :: forall a . (Eq a) => a -> a -> Bool

(>) :: forall a . (Ord a) => a -> a -> Bool

(>=) :: forall a . (Ord a) => a -> a -> Bool

abs :: forall a . (Num a) => a -> a

buildtree :: forall a . (Ord a) => [a] -> Btree a

ceiling ::

forall a b . (RealFrac a, Integral b) => a -> b

compare :: forall a . (Ord a) => a -> a -> Ordering

default__abs :: forall a . (Num a) => a -> a

default__ceiling ::

forall a b . (RealFrac a, Integral b) => a -> b

default__compare ::

forall a . (Ord a) => a -> a -> Ordering

default__div ::

forall a . (Integral a) => a -> a -> a

default__divMod ::

forall a . (Integral a) => a -> a -> (a, a)

default__enumFrom :: forall a . (Enum a) => a -> [a]

default__enumFromThen ::

forall a . (Enum a) => a -> a -> [a]

default__enumFromThenTo ::

forall a . (Enum a) => a -> a -> a -> [a]

default__enumFromTo ::

forall a . (Enum a) => a -> a -> [a]

default__floor ::

forall a b . (RealFrac a, Integral b) => a -> b

default__fromEnum :: forall a . (Enum a) => a -> Int

default__fromInteger ::

forall a . (Num a) => Integer -> a

default__fromRational ::

forall a . (Fractional a) => Rational -> a

default__max :: forall a . (Ord a) => a -> a -> a

default__maxBound :: forall a . (Bounded a) => a

default__min :: forall a . (Ord a) => a -> a -> a

default__minBound :: forall a . (Bounded a) => a

default__mod ::

forall a . (Integral a) => a -> a -> a

default__negate :: forall a . (Num a) => a -> a

default__pred :: forall a . (Enum a) => a -> a

default__properFraction ::

forall a b . (RealFrac a, Integral b) => a -> (b, a)

default__quot ::

forall a . (Integral a) => a -> a -> a

default__quotRem ::

forall a . (Integral a) => a -> a -> (a, a)

default__recip :: forall a . (Fractional a) => a -> a

default__rem ::

forall a . (Integral a) => a -> a -> a

default__round ::

forall a b . (RealFrac a, Integral b) => a -> b

default__show :: forall a . (Show a) => a -> String

default__showList ::

forall a . (Show a) => [a] -> ShowS

default__showsPrec ::

forall a . (Show a) => Int -> a -> ShowS

default__signum :: forall a . (Num a) => a -> a

default__succ :: forall a . (Enum a) => a -> a

default__toEnum :: forall a . (Enum a) => Int -> a

default__toInteger ::

forall a . (Integral a) => a -> Integer

default__toRational ::

forall a . (Real a) => a -> Rational

default__truncate ::

forall a b . (RealFrac a, Integral b) => a -> b

derived__Prelude_Eq_184_27 :: Eq ()

derived__Prelude_Eq_188_20 ::

forall a b . (Eq a) -> (Eq b) -> Eq (a, b)

derived__Prelude_Eq_192_20 ::

forall a b c .

(Eq a) -> (Eq b) -> (Eq c) -> Eq (a, b, c)

derived__Prelude_Eq_196_20 ::

forall a b c d .

(Eq a) ->

(Eq b) -> (Eq c) -> (Eq d) -> Eq (a, b, c, d)

derived__Prelude_Eq_34_65 ::

forall a . (Eq a) -> Eq [a]

derived__Prelude_Eq_Bool :: Eq Bool

derived__Prelude_Eq_Ordering :: Eq Ordering

derived__Prelude_Ord_184_31 :: Ord ()

derived__Prelude_Ord_188_24 ::

forall a b . (Ord a) -> (Ord b) -> Ord (a, b)

derived__Prelude_Ord_192_24 ::

forall a b c .

(Ord a) -> (Ord b) -> (Ord c) -> Ord (a, b, c)

derived__Prelude_Ord_196_24 ::

forall a b c d .

(Ord a) ->

(Ord b) -> (Ord c) -> (Ord d) -> Ord (a, b, c, d)

derived__Prelude_Ord_34_69 ::

forall a . (Ord a) -> Ord [a]

derived__Prelude_Ord_Bool :: Ord Bool

derived__Prelude_Ord_Ordering :: Ord Ordering

derived__Prelude_Show_184_36 :: Show ()

derived__Prelude_Show_188_14 ::

forall a b . (Show a) -> (Show b) -> Show (a, b)

derived__Prelude_Show_192_14 ::

forall a b c .

(Show a) -> (Show b) -> (Show c) -> Show (a, b, c)

derived__Prelude_Show_196_14 ::

forall a b c d .

(Show a) ->

(Show b) -> (Show c) -> (Show d) -> Show (a, b, c, d)

derived__Prelude_Show_34_59 ::

forall a . (Show a) -> Show [a]

derived__Prelude_Show_Bool :: Show Bool

derived__Prelude_Show_Btree ::

forall a . (Show a) -> Show (Btree a)

derived__Prelude_Show_Ordering :: Show Ordering

div :: forall a . (Integral a) => a -> a -> a

divMod :: forall a . (Integral a) => a -> a -> (a, a)

enumFrom :: forall a . (Enum a) => a -> [a]

enumFromThen :: forall a . (Enum a) => a -> a -> [a]

enumFromThenTo ::

forall a . (Enum a) => a -> a -> a -> [a]

enumFromTo :: forall a . (Enum a) => a -> a -> [a]

error :: forall a . String -> a

even :: forall a . (Integral a) => a -> Bool

flip :: forall a b c . (a -> b -> c) -> b -> a -> c

floor ::

forall a b . (RealFrac a, Integral b) => a -> b

fromEnum :: forall a . (Enum a) => a -> Int

fromInteger :: forall a . (Num a) => Integer -> a

fromIntegral ::

forall a b . (Integral a, Num b) => a -> b

fromRational ::

forall a . (Fractional a) => Rational -> a

head :: forall a . [a] -> a

insert ::

forall a . (Ord a) => a -> (Btree a) -> Btree a

inst__Prelude_Enum_Int :: Enum Int

inst__Prelude_Eq_Char :: Eq Char

inst__Prelude_Eq_Double :: Eq Double

inst__Prelude_Eq_Int :: Eq Int

inst__Prelude_Eq_Integer :: Eq Integer

inst__Prelude_Eq_Rational :: Eq Rational

inst__Prelude_Fractional_Double :: Fractional Double

inst__Prelude_Fractional_Rational ::

Fractional Rational

inst__Prelude_Num_Double :: Num Double

inst__Prelude_Num_Int :: Num Int

inst__Prelude_Num_Integer :: Num Integer

inst__Prelude_Num_Rational :: Num Rational

inst__Prelude_Ord_Char :: Ord Char

inst__Prelude_Ord_Double :: Ord Double

inst__Prelude_Ord_Int :: Ord Int

inst__Prelude_Ord_Integer :: Ord Integer

inst__Prelude_Ord_Rational :: Ord Rational

inst__Prelude_Show_Char :: Show Char

inst__Prelude_Show_Double :: Show Double

inst__Prelude_Show_Int :: Show Int

inst__Prelude_Show_Integer :: Show Integer

inst__Prelude_Show_Rational :: Show Rational

lexOrder :: Ordering -> Ordering -> Ordering

main :: Btree Int

map :: forall a b . (a -> b) -> [a] -> [b]

max :: forall a . (Ord a) => a -> a -> a

maxBound :: forall a . (Bounded a) => a

min :: forall a . (Ord a) => a -> a -> a

minBound :: forall a . (Bounded a) => a

mod :: forall a . (Integral a) => a -> a -> a

negate :: forall a . (Num a) => a -> a

not :: Bool -> Bool

odd :: forall a . (Integral a) => a -> Bool

otherwise :: Bool

pred :: forall a . (Enum a) => a -> a

primError :: forall a . String -> a

properFraction ::

forall a b . (RealFrac a, Integral b) => a -> (b, a)

quot :: forall a . (Integral a) => a -> a -> a

quotRem ::

forall a . (Integral a) => a -> a -> (a, a)

recip :: forall a . (Fractional a) => a -> a

rem :: forall a . (Integral a) => a -> a -> a

round ::

forall a b . (RealFrac a, Integral b) => a -> b

show :: forall a . (Show a) => a -> String

showArgument ::

forall a . (Show a) => a -> String -> String

showChar :: Char -> ShowS

showList :: forall a . (Show a) => [a] -> ShowS

showParen :: Bool -> ShowS -> ShowS

showParenArg :: Int -> ShowS -> ShowS

showString :: String -> ShowS

shows :: forall a . (Show a) => a -> ShowS

showsPrec :: forall a . (Show a) => Int -> a -> ShowS

signum :: forall a . (Num a) => a -> a

subtract :: forall a . (Num a) => a -> a -> a

succ :: forall a . (Enum a) => a -> a

tail :: forall a . [a] -> [a]

toEnum :: forall a . (Enum a) => Int -> a

toInteger :: forall a . (Integral a) => a -> Integer

toRational :: forall a . (Real a) => a -> Rational

truncate ::

forall a b . (RealFrac a, Integral b) => a -> b

() :: ()

(,) :: forall a b . a -> b -> (a, b)

Prelude.(,,) ::

forall a b c . a -> b -> c -> (a, b, c)

Prelude.(,,,) ::

forall a b c d . a -> b -> c -> d -> (a, b, c, d)

(:) :: forall a . a -> [a] -> [a]

EQ :: Ordering

Empty :: forall a . Btree a

False :: Bool

GT :: Ordering

LT :: Ordering

T ::

forall a . a -> (Btree a) -> (Btree a) -> Btree a

True :: Bool

[] :: forall a . [a]

scope:

Prelude.&& |-> Prelude.&&, Value

() |-> Prelude.(), Type [()] []

() |-> Prelude.(), con of ()

(,) |-> Prelude.(,), Type [(,)] []

(,) |-> Prelude.(,), con of (,)

Prelude.(,,) |-> Prelude.(,,), Type [(,,)] []

Prelude.(,,) |-> Prelude.(,,), con of (,,)

Prelude.(,,,) |-> Prelude.(,,,), Type [(,,,)] []

Prelude.(,,,) |-> Prelude.(,,,), con of (,,,)

Prelude.* |-> Prelude.*, method of Num

Prelude.+ |-> Prelude.+, method of Num

Prelude.++ |-> Prelude.++, Value

Prelude.- |-> Prelude.-, method of Num

(->) |-> Prelude.->, Type [] []

Prelude.. |-> Prelude.., Value

Prelude./ |-> Prelude./, method of Fractional

Prelude./= |-> Prelude./=, method of Eq

Prelude.: |-> Prelude.:, con of []

Prelude.< |-> Prelude.<, method of Ord

Prelude.<= |-> Prelude.<=, method of Ord

Prelude.== |-> Prelude.==, method of Eq

Prelude.> |-> Prelude.>, method of Ord

Prelude.>= |-> Prelude.>=, method of Ord

Prelude.Bool |-> Prelude.Bool, Type [False, True] []

Prelude.Bounded |-> Prelude.Bounded, Class [minBound,

maxBound]

Prelude.Btree |-> Prelude.Btree, Type [Empty, T] []

Prelude.Char |-> Prelude.Char, Type [] []

Prelude.Double |-> Prelude.Double, Type [] []

Prelude.EQ |-> Prelude.EQ, con of Ordering

Prelude.Empty |-> Prelude.Empty, con of Btree

Prelude.Enum |-> Prelude.Enum, Class [succ, pred,

toEnum, fromEnum, enumFrom, enumFromThen,

enumFromTo, enumFromThenTo]

Prelude.Eq |-> Prelude.Eq, Class [==, /=]

Prelude.False |-> Prelude.False, con of Bool

Prelude.Fractional |-> Prelude.Fractional, Class [/,

recip, fromRational]

Prelude.GT |-> Prelude.GT, con of Ordering

Prelude.Int |-> Prelude.Int, Type [] []

Prelude.Integer |-> Prelude.Integer, Type [] []

Prelude.Integral |-> Prelude.Integral, Class [quot,

rem, div, mod, quotRem, divMod,

toInteger]

Prelude.LT |-> Prelude.LT, con of Ordering

Prelude.Num |-> Prelude.Num, Class [+, -, *, negate,

abs, signum, fromInteger]

Prelude.Ord |-> Prelude.Ord, Class [compare, <, <=,

>=, >, max, min]

Prelude.Ordering |-> Prelude.Ordering, Type [LT, EQ,

GT] []

Prelude.Rational |-> Prelude.Rational, Type [] []

Prelude.Real |-> Prelude.Real, Class [toRational]

Prelude.RealFrac |-> Prelude.RealFrac, Class [properFraction,

truncate, round, ceiling, floor]

Prelude.Show |-> Prelude.Show, Class [showsPrec,

show, showList]

Prelude.ShowS |-> Prelude.ShowS, Type [] []

Prelude.String |-> Prelude.String, Type [] []

Prelude.T |-> Prelude.T, con of Btree

Prelude.True |-> Prelude.True, con of Bool

[] |-> Prelude.[], Type [[], :] [head, tail]

[] |-> Prelude.[], con of []

Prelude.abs |-> Prelude.abs, method of Num

Prelude.buildtree |-> Prelude.buildtree, Value

Prelude.ceiling |-> Prelude.ceiling, method of RealFrac

Prelude.compare |-> Prelude.compare, method of Ord

Prelude.div |-> Prelude.div, method of Integral

Prelude.divMod |-> Prelude.divMod, method of Integral

Prelude.enumFrom |-> Prelude.enumFrom, method of Enum

Prelude.enumFromThen |-> Prelude.enumFromThen, method of Enum

Prelude.enumFromThenTo |-> Prelude.enumFromThenTo, method of Enum

Prelude.enumFromTo |-> Prelude.enumFromTo, method of Enum

Prelude.error |-> Prelude.error, Value

Prelude.even |-> Prelude.even, Value

Prelude.flip |-> Prelude.flip, Value

Prelude.floor |-> Prelude.floor, method of RealFrac

Prelude.fromEnum |-> Prelude.fromEnum, method of Enum

Prelude.fromInteger |-> Prelude.fromInteger, method of Num

Prelude.fromIntegral |-> Prelude.fromIntegral, Value

Prelude.fromRational |-> Prelude.fromRational, method of Fractional

Prelude.head |-> Prelude.head, field of []

Prelude.insert |-> Prelude.insert, Value

Prelude.lexOrder |-> Prelude.lexOrder, Value

Prelude.main |-> Prelude.main, Value

Prelude.map |-> Prelude.map, Value

Prelude.max |-> Prelude.max, method of Ord

Prelude.maxBound |-> Prelude.maxBound, method of Bounded

Prelude.min |-> Prelude.min, method of Ord

Prelude.minBound |-> Prelude.minBound, method of Bounded

Prelude.mod |-> Prelude.mod, method of Integral

Prelude.negate |-> Prelude.negate, method of Num

Prelude.not |-> Prelude.not, Value

Prelude.odd |-> Prelude.odd, Value

Prelude.otherwise |-> Prelude.otherwise, Value

Prelude.pred |-> Prelude.pred, method of Enum

Prelude.primError |-> Prelude.primError, Value

Prelude.properFraction |-> Prelude.properFraction, method of RealFrac

Prelude.quot |-> Prelude.quot, method of Integral

Prelude.quotRem |-> Prelude.quotRem, method of Integral

Prelude.recip |-> Prelude.recip, method of Fractional

Prelude.rem |-> Prelude.rem, method of Integral

Prelude.round |-> Prelude.round, method of RealFrac

Prelude.show |-> Prelude.show, method of Show

Prelude.showArgument |-> Prelude.showArgument, Value

Prelude.showChar |-> Prelude.showChar, Value

Prelude.showList |-> Prelude.showList, method of Show

Prelude.showParen |-> Prelude.showParen, Value

Prelude.showParenArg |-> Prelude.showParenArg, Value

Prelude.showString |-> Prelude.showString, Value

Prelude.shows |-> Prelude.shows, Value

Prelude.showsPrec |-> Prelude.showsPrec, method of Show

Prelude.signum |-> Prelude.signum, method of Num

Prelude.subtract |-> Prelude.subtract, Value

Prelude.succ |-> Prelude.succ, method of Enum

Prelude.tail |-> Prelude.tail, field of []

Prelude.toEnum |-> Prelude.toEnum, method of Enum

Prelude.toInteger |-> Prelude.toInteger, method of Integral

Prelude.toRational |-> Prelude.toRational, method of Real

Prelude.truncate |-> Prelude.truncate, method of RealFrac

&& |-> Prelude.&&, Value

() |-> Prelude.(), Type [()] []

() |-> Prelude.(), con of ()

(,) |-> Prelude.(,), Type [(,)] []

(,) |-> Prelude.(,), con of (,)

(,,) |-> Prelude.(,,), Type [(,,)] []

(,,) |-> Prelude.(,,), con of (,,)

(,,,) |-> Prelude.(,,,), Type [(,,,)] []

(,,,) |-> Prelude.(,,,), con of (,,,)

* |-> Prelude.*, method of Num

+ |-> Prelude.+, method of Num

++ |-> Prelude.++, Value

- |-> Prelude.-, method of Num

-> |-> Prelude.->, Type [] []

. |-> Prelude.., Value

/ |-> Prelude./, method of Fractional

/= |-> Prelude./=, method of Eq

: |-> Prelude.:, con of []

< |-> Prelude.<, method of Ord

<= |-> Prelude.<=, method of Ord

== |-> Prelude.==, method of Eq

> |-> Prelude.>, method of Ord

>= |-> Prelude.>=, method of Ord

Bool |-> Prelude.Bool, Type [False, True] []

Bounded |-> Prelude.Bounded, Class [minBound,

maxBound]

Btree |-> Prelude.Btree, Type [Empty, T] []

Char |-> Prelude.Char, Type [] []

Double |-> Prelude.Double, Type [] []

EQ |-> Prelude.EQ, con of Ordering

Empty |-> Prelude.Empty, con of Btree

Enum |-> Prelude.Enum, Class [succ, pred, toEnum,

fromEnum, enumFrom, enumFromThen, enumFromTo,

enumFromThenTo]

Eq |-> Prelude.Eq, Class [==, /=]

False |-> Prelude.False, con of Bool

Fractional |-> Prelude.Fractional, Class [/, recip,

fromRational]

GT |-> Prelude.GT, con of Ordering

Int |-> Prelude.Int, Type [] []

Integer |-> Prelude.Integer, Type [] []

Integral |-> Prelude.Integral, Class [quot, rem, div,

mod, quotRem, divMod, toInteger]

LT |-> Prelude.LT, con of Ordering

Num |-> Prelude.Num, Class [+, -, *, negate, abs,

signum, fromInteger]

Ord |-> Prelude.Ord, Class [compare, <, <=, >=, >,

max, min]

Ordering |-> Prelude.Ordering, Type [LT, EQ, GT] []

Rational |-> Prelude.Rational, Type [] []

Real |-> Prelude.Real, Class [toRational]

RealFrac |-> Prelude.RealFrac, Class [properFraction,

truncate, round, ceiling, floor]

Show |-> Prelude.Show, Class [showsPrec, show,

showList]

ShowS |-> Prelude.ShowS, Type [] []

String |-> Prelude.String, Type [] []

T |-> Prelude.T, con of Btree

True |-> Prelude.True, con of Bool

[] |-> Prelude.[], Type [[], :] [head, tail]

[] |-> Prelude.[], con of []

abs |-> Prelude.abs, method of Num

buildtree |-> Prelude.buildtree, Value

ceiling |-> Prelude.ceiling, method of RealFrac

compare |-> Prelude.compare, method of Ord

div |-> Prelude.div, method of Integral

divMod |-> Prelude.divMod, method of Integral

enumFrom |-> Prelude.enumFrom, method of Enum

enumFromThen |-> Prelude.enumFromThen, method of Enum

enumFromThenTo |-> Prelude.enumFromThenTo, method of Enum

enumFromTo |-> Prelude.enumFromTo, method of Enum

error |-> Prelude.error, Value

even |-> Prelude.even, Value

flip |-> Prelude.flip, Value

floor |-> Prelude.floor, method of RealFrac

fromEnum |-> Prelude.fromEnum, method of Enum

fromInteger |-> Prelude.fromInteger, method of Num

fromIntegral |-> Prelude.fromIntegral, Value

fromRational |-> Prelude.fromRational, method of Fractional

head |-> Prelude.head, field of []

insert |-> Prelude.insert, Value

lexOrder |-> Prelude.lexOrder, Value

main |-> Prelude.main, Value

map |-> Prelude.map, Value

max |-> Prelude.max, method of Ord

maxBound |-> Prelude.maxBound, method of Bounded

min |-> Prelude.min, method of Ord

minBound |-> Prelude.minBound, method of Bounded

mod |-> Prelude.mod, method of Integral

negate |-> Prelude.negate, method of Num

not |-> Prelude.not, Value

odd |-> Prelude.odd, Value

otherwise |-> Prelude.otherwise, Value

pred |-> Prelude.pred, method of Enum

primError |-> Prelude.primError, Value

properFraction |-> Prelude.properFraction, method of RealFrac

quot |-> Prelude.quot, method of Integral

quotRem |-> Prelude.quotRem, method of Integral

recip |-> Prelude.recip, method of Fractional

rem |-> Prelude.rem, method of Integral

round |-> Prelude.round, method of RealFrac

show |-> Prelude.show, method of Show

showArgument |-> Prelude.showArgument, Value

showChar |-> Prelude.showChar, Value

showList |-> Prelude.showList, method of Show

showParen |-> Prelude.showParen, Value

showParenArg |-> Prelude.showParenArg, Value

showString |-> Prelude.showString, Value

shows |-> Prelude.shows, Value

showsPrec |-> Prelude.showsPrec, method of Show

signum |-> Prelude.signum, method of Num

subtract |-> Prelude.subtract, Value

succ |-> Prelude.succ, method of Enum

tail |-> Prelude.tail, field of []

toEnum |-> Prelude.toEnum, method of Enum

toInteger |-> Prelude.toInteger, method of Integral

toRational |-> Prelude.toRational, method of Real

truncate |-> Prelude.truncate, method of RealFrac

-}

module Dummy where

import Prelude (error, Show, Eq, Ord)

import MyLogic

otherwise = True

lexOrder EQ o = o

lexOrder o _ = o

showArgument d208 x

= (.){-String String String-} (showChar ' ')

(showsPrec{-t203-} d208

(fromInteger{-Int-} inst__Prelude_Num_Int 10)

x)

data Integer

data Rational

data Double

data Char

data Int

data a -> b

data Bool = False | True deriving (Show, Eq, Ord)

not :: Bool -> Bool

not True = False

not False = True

(&&) :: Bool -> Bool -> Bool

(&&) a b = if a then True else b

data Ordering = LT | EQ | GT deriving (Show, Eq, Ord)

class Eq a where (==),(/=) :: a -> a -> Bool

($--/=) d220 x y = not ((==){-a-} d220 x y)

($--==) d226 x y = not ((/=){-a-} d226 x y)

data [a]

= [] | (:) {head :: a, tail :: [a]}

deriving (Show, Eq, Ord)

(++) :: [a] -> [a] -> [a]

(++) [] ys = ys

(++) ((:){-a-} x xs) ys

= (:){-a-} x ((++){-a-} xs ys)

map :: (a -> b) -> [a] -> [b]

map f [] = []

map f ((:){-a-} x xs)

= (:){-b-} (f x) (map{-a b-} f xs)

type String = String

foreign import primError :: String -> a

error :: String -> a

error = primError{-a-}

(.) :: (b -> c) -> (a -> b) -> a -> c

(.) f g = \ x -> f (g x)

type ShowS = String -> String

class Eq a => Ord a

where

compare :: a -> a -> Ordering

(<),(<=),(>=),(>) :: a -> a -> Bool

max,min :: a -> a -> a

default__compare d266 x y

| (==){-a-} d263 x y = EQ

| (<=){-a-} d266 x y = LT

| otherwise = GT

where

d263 = super1_Ord{-a-} d266

{-

d263 :: Eq a

-}

($--<=) d274 x y

= (/=){-Ordering-} derived__Prelude_Eq_Ordering

(compare{-a-} d274 x y)

GT

($--<) d282 x y

= (==){-Ordering-} derived__Prelude_Eq_Ordering

(compare{-a-} d282 x y)

LT

($-->=) d290 x y

= (/=){-Ordering-} derived__Prelude_Eq_Ordering

(compare{-a-} d290 x y)

LT

($-->) d298 x y

= (==){-Ordering-} derived__Prelude_Eq_Ordering

(compare{-a-} d298 x y)

GT

default__max d304 x y

| (<=){-a-} d304 x y = y

| otherwise = x

default__min d310 x y

| (<=){-a-} d310 x y = x

| otherwise = y

shows :: Show a => a -> ShowS

shows d319

= showsPrec{-a-} d319

(fromInteger{-Int-} inst__Prelude_Num_Int 0)

showChar :: Char -> ShowS

showChar = (:){-Char-}

showString :: String -> ShowS

showString = (++){-Char-}

showParen :: Bool -> ShowS -> ShowS

showParen b p

= if b

then (.){-String String String-}

((.){-String String String-} (showChar '(') p)

(showChar ')')

else p

showParenArg :: Int -> ShowS -> ShowS

showParenArg d

= showParen

((<=){-Int-} inst__Prelude_Ord_Int

(fromInteger{-Int-} inst__Prelude_Num_Int 10)

d)

class Show a

where

showsPrec :: Int -> a -> ShowS

show :: a -> String

showList :: [a] -> ShowS

default__showsPrec d346 _ x s

= (++){-Char-} (show{-a-} d346 x) s

default__show d354 x

= showsPrec{-a-} d354

(fromInteger{-Int-} inst__Prelude_Num_Int 0)

x

""

default__showList d384 [] = showString "[]"

default__showList d384 ((:){-a-} x xs)

= (.){-String String String-}

((.){-String String String-} (showChar '[')

(shows{-a-} d384 x))

(showl{-a-} d384 xs)

where

showl d372 [] = showChar ']'

showl d372 ((:){-t361-} x xs)

= (.){-String String String-}

((.){-String String String-} (showChar ',')

(shows{-t361-} d372 x))

(showl{-t361-} d372 xs)

{-

showl ::

forall a . (Show a) => [a] -> String -> String

-}

class (Eq a, Show a) => Num a

where

(+),(-),(*) :: a -> a -> a

negate :: a -> a

abs,signum :: a -> a

fromInteger :: Integer -> a

($--+) d393

= error{-(a -> a -> a)-} "No default for method +"

($---) d396

= error{-(a -> a -> a)-} "No default for method -"

($--*) d399

= error{-(a -> a -> a)-} "No default for method *"

default__negate d402

= error{-(a -> a)-} "No default for method negate"

default__abs d405

= error{-(a -> a)-} "No default for method abs"

default__signum d408

= error{-(a -> a)-} "No default for method signum"

default__fromInteger d411

= error{-(Integer -> a)-}

"No default for method fromInteger"

class Num a => Fractional a

where

(/) :: a -> a -> a

recip :: a -> a

fromRational :: Rational -> a

($--/) d416

= error{-(a -> a -> a)-} "No default for method /"

default__recip d419

= error{-(a -> a)-} "No default for method recip"

default__fromRational d422

= error{-(Rational -> a)-}

"No default for method fromRational"

instance Num Int

where

super1_Num = super{-(Eq Int)-} inst__Prelude_Eq_Int

super2_Num

= super{-(Show Int)-} inst__Prelude_Show_Int

(+) = ($--+){-Int-} inst__Prelude_Num_Int

(-) = ($---){-Int-} inst__Prelude_Num_Int

(*) = ($--*){-Int-} inst__Prelude_Num_Int

negate = default__negate{-Int-} inst__Prelude_Num_Int

abs = default__abs{-Int-} inst__Prelude_Num_Int

signum = default__signum{-Int-} inst__Prelude_Num_Int

fromInteger

= default__fromInteger{-Int-} inst__Prelude_Num_Int

{-

super1_Num :: Eq Int

super2_Num :: Show Int

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

-}

instance Num Integer

where

super1_Num

= super{-(Eq Integer)-} inst__Prelude_Eq_Integer

super2_Num

= super{-(Show Integer)-} inst__Prelude_Show_Integer

(+) = ($--+){-Integer-} inst__Prelude_Num_Integer

(-) = ($---){-Integer-} inst__Prelude_Num_Integer

(*) = ($--*){-Integer-} inst__Prelude_Num_Integer

negate

= default__negate{-Integer-}

inst__Prelude_Num_Integer

abs = default__abs{-Integer-}

inst__Prelude_Num_Integer

signum

= default__signum{-Integer-}

inst__Prelude_Num_Integer

fromInteger

= default__fromInteger{-Integer-}

inst__Prelude_Num_Integer

{-

super1_Num :: Eq Integer

super2_Num :: Show Integer

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

-}

instance Num Rational

where

super1_Num

= super{-(Eq Rational)-} inst__Prelude_Eq_Rational

super2_Num

= super{-(Show Rational)-}

inst__Prelude_Show_Rational

(+) = ($--+){-Rational-} inst__Prelude_Num_Rational

(-) = ($---){-Rational-} inst__Prelude_Num_Rational

(*) = ($--*){-Rational-} inst__Prelude_Num_Rational

negate

= default__negate{-Rational-}

inst__Prelude_Num_Rational

abs = default__abs{-Rational-}

inst__Prelude_Num_Rational

signum

= default__signum{-Rational-}

inst__Prelude_Num_Rational

fromInteger

= default__fromInteger{-Rational-}

inst__Prelude_Num_Rational

{-

super1_Num :: Eq Rational

super2_Num :: Show Rational

(+) :: Rational -> Rational -> Rational

(-) :: Rational -> Rational -> Rational

(*) :: Rational -> Rational -> Rational

negate :: Rational -> Rational

abs :: Rational -> Rational

signum :: Rational -> Rational

fromInteger :: Integer -> Rational

-}

instance Num Double

where

super1_Num

= super{-(Eq Double)-} inst__Prelude_Eq_Double

super2_Num

= super{-(Show Double)-} inst__Prelude_Show_Double

(+) = ($--+){-Double-} inst__Prelude_Num_Double

(-) = ($---){-Double-} inst__Prelude_Num_Double

(*) = ($--*){-Double-} inst__Prelude_Num_Double

negate

= default__negate{-Double-} inst__Prelude_Num_Double

abs = default__abs{-Double-} inst__Prelude_Num_Double

signum

= default__signum{-Double-} inst__Prelude_Num_Double

fromInteger

= default__fromInteger{-Double-}

inst__Prelude_Num_Double

{-

super1_Num :: Eq Double

super2_Num :: Show Double

(+) :: Double -> Double -> Double

(-) :: Double -> Double -> Double

(*) :: Double -> Double -> Double

negate :: Double -> Double

abs :: Double -> Double

signum :: Double -> Double

fromInteger :: Integer -> Double

-}

instance Eq Int

where

(==) = ($--==){-Int-} inst__Prelude_Eq_Int

(/=) = ($--/=){-Int-} inst__Prelude_Eq_Int

{-

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

-}

instance Ord Int

where

super1_Ord = super{-(Eq Int)-} inst__Prelude_Eq_Int

compare

= default__compare{-Int-} inst__Prelude_Ord_Int

(<) = ($--<){-Int-} inst__Prelude_Ord_Int

(<=) = ($--<=){-Int-} inst__Prelude_Ord_Int

(>=) = ($-->=){-Int-} inst__Prelude_Ord_Int

(>) = ($-->){-Int-} inst__Prelude_Ord_Int

max = default__max{-Int-} inst__Prelude_Ord_Int

min = default__min{-Int-} inst__Prelude_Ord_Int

{-

super1_Ord :: Eq Int

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

-}

instance Enum Int

where

succ = default__succ{-Int-} inst__Prelude_Enum_Int

pred = default__pred{-Int-} inst__Prelude_Enum_Int

toEnum

= default__toEnum{-Int-} inst__Prelude_Enum_Int

fromEnum

= default__fromEnum{-Int-} inst__Prelude_Enum_Int

enumFrom

= default__enumFrom{-Int-} inst__Prelude_Enum_Int

enumFromThen

= default__enumFromThen{-Int-} inst__Prelude_Enum_Int

enumFromTo

= default__enumFromTo{-Int-} inst__Prelude_Enum_Int

enumFromThenTo

= default__enumFromThenTo{-Int-}

inst__Prelude_Enum_Int

{-

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

-}

instance Eq Char

where

(==) = ($--==){-Char-} inst__Prelude_Eq_Char

(/=) = ($--/=){-Char-} inst__Prelude_Eq_Char

{-

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

-}

instance Eq Integer

where

(==) = ($--==){-Integer-} inst__Prelude_Eq_Integer

(/=) = ($--/=){-Integer-} inst__Prelude_Eq_Integer

{-

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

-}

instance Eq Rational

where

(==) = ($--==){-Rational-} inst__Prelude_Eq_Rational

(/=) = ($--/=){-Rational-} inst__Prelude_Eq_Rational

{-

(==) :: Rational -> Rational -> Bool

(/=) :: Rational -> Rational -> Bool

-}

instance Eq Double

where

(==) = ($--==){-Double-} inst__Prelude_Eq_Double

(/=) = ($--/=){-Double-} inst__Prelude_Eq_Double

{-

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

-}

instance Ord Char

where

super1_Ord = super{-(Eq Char)-} inst__Prelude_Eq_Char

compare

= default__compare{-Char-} inst__Prelude_Ord_Char

(<) = ($--<){-Char-} inst__Prelude_Ord_Char

(<=) = ($--<=){-Char-} inst__Prelude_Ord_Char

(>=) = ($-->=){-Char-} inst__Prelude_Ord_Char

(>) = ($-->){-Char-} inst__Prelude_Ord_Char

max = default__max{-Char-} inst__Prelude_Ord_Char

min = default__min{-Char-} inst__Prelude_Ord_Char

{-

super1_Ord :: Eq Char

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

-}

instance Ord Integer

where

super1_Ord

= super{-(Eq Integer)-} inst__Prelude_Eq_Integer

compare

= default__compare{-Integer-}

inst__Prelude_Ord_Integer

(<) = ($--<){-Integer-} inst__Prelude_Ord_Integer

(<=) = ($--<=){-Integer-} inst__Prelude_Ord_Integer

(>=) = ($-->=){-Integer-} inst__Prelude_Ord_Integer

(>) = ($-->){-Integer-} inst__Prelude_Ord_Integer

max = default__max{-Integer-}

inst__Prelude_Ord_Integer

min = default__min{-Integer-}

inst__Prelude_Ord_Integer

{-

super1_Ord :: Eq Integer

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

-}

instance Ord Rational

where

super1_Ord

= super{-(Eq Rational)-} inst__Prelude_Eq_Rational

compare

= default__compare{-Rational-}

inst__Prelude_Ord_Rational

(<) = ($--<){-Rational-} inst__Prelude_Ord_Rational

(<=) = ($--<=){-Rational-} inst__Prelude_Ord_Rational

(>=) = ($-->=){-Rational-} inst__Prelude_Ord_Rational

(>) = ($-->){-Rational-} inst__Prelude_Ord_Rational

max = default__max{-Rational-}

inst__Prelude_Ord_Rational

min = default__min{-Rational-}

inst__Prelude_Ord_Rational

{-

super1_Ord :: Eq Rational

compare :: Rational -> Rational -> Ordering

(<) :: Rational -> Rational -> Bool

(<=) :: Rational -> Rational -> Bool

(>=) :: Rational -> Rational -> Bool

(>) :: Rational -> Rational -> Bool

max :: Rational -> Rational -> Rational

min :: Rational -> Rational -> Rational

-}

instance Ord Double

where

super1_Ord

= super{-(Eq Double)-} inst__Prelude_Eq_Double

compare

= default__compare{-Double-} inst__Prelude_Ord_Double

(<) = ($--<){-Double-} inst__Prelude_Ord_Double

(<=) = ($--<=){-Double-} inst__Prelude_Ord_Double

(>=) = ($-->=){-Double-} inst__Prelude_Ord_Double

(>) = ($-->){-Double-} inst__Prelude_Ord_Double

max = default__max{-Double-} inst__Prelude_Ord_Double

min = default__min{-Double-} inst__Prelude_Ord_Double

{-

super1_Ord :: Eq Double

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

-}

instance Show Int

where

showsPrec

= default__showsPrec{-Int-} inst__Prelude_Show_Int

show = default__show{-Int-} inst__Prelude_Show_Int

showList

= default__showList{-Int-} inst__Prelude_Show_Int

{-

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

-}

instance Show Char

where

showsPrec

= default__showsPrec{-Char-} inst__Prelude_Show_Char

show = default__show{-Char-} inst__Prelude_Show_Char

showList

= default__showList{-Char-} inst__Prelude_Show_Char

{-

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: String -> ShowS

-}

instance Show Integer

where

showsPrec

= default__showsPrec{-Integer-}

inst__Prelude_Show_Integer

show

= default__show{-Integer-} inst__Prelude_Show_Integer

showList

= default__showList{-Integer-}

inst__Prelude_Show_Integer

{-

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

-}

instance Show Rational

where

showsPrec

= default__showsPrec{-Rational-}

inst__Prelude_Show_Rational

show

= default__show{-Rational-}

inst__Prelude_Show_Rational

showList

= default__showList{-Rational-}

inst__Prelude_Show_Rational

{-

showsPrec :: Int -> Rational -> ShowS

show :: Rational -> String

showList :: [Rational] -> ShowS

-}

instance Show Double

where

showsPrec

= default__showsPrec{-Double-}

inst__Prelude_Show_Double

show

= default__show{-Double-} inst__Prelude_Show_Double

showList

= default__showList{-Double-}

inst__Prelude_Show_Double

{-

showsPrec :: Int -> Double -> ShowS

show :: Double -> String

showList :: [Double] -> ShowS

-}

instance Fractional Rational

where

super1_Fractional

= super{-(Num Rational)-} inst__Prelude_Num_Rational

(/) = ($--/){-Rational-}

inst__Prelude_Fractional_Rational

recip

= default__recip{-Rational-}

inst__Prelude_Fractional_Rational

fromRational

= default__fromRational{-Rational-}

inst__Prelude_Fractional_Rational

{-

super1_Fractional :: Num Rational

(/) :: Rational -> Rational -> Rational

recip :: Rational -> Rational

fromRational :: Rational -> Rational

-}

instance Fractional Double

where

super1_Fractional

= super{-(Num Double)-} inst__Prelude_Num_Double

(/) = ($--/){-Double-}

inst__Prelude_Fractional_Double

recip

= default__recip{-Double-}

inst__Prelude_Fractional_Double

fromRational

= default__fromRational{-Double-}

inst__Prelude_Fractional_Double

{-

super1_Fractional :: Num Double

(/) :: Double -> Double -> Double

recip :: Double -> Double

fromRational :: Rational -> Double

-}

subtract :: Num a => a -> a -> a

subtract d782 = flip{-a a a-} ((-){-a-} d782)

flip :: (a -> b -> c) -> b -> a -> c

flip f x y = f y x

class Enum a

where

succ,pred :: a -> a

toEnum :: Int -> a

fromEnum :: a -> Int

enumFrom :: a -> [a]

enumFromThen :: a -> a -> [a]

enumFromTo :: a -> a -> [a]

enumFromThenTo :: a -> a -> a -> [a]

default__succ d807

= (.){-Int a a-}

((.){-Int a Int-} (toEnum{-a-} d807)

(flip{-Int Int Int-}

((+){-Int-} inst__Prelude_Num_Int)

(fromInteger{-Int-} inst__Prelude_Num_Int 1)))

(fromEnum{-a-} d807)

default__pred d823

= (.){-Int a a-}

((.){-Int a Int-} (toEnum{-a-} d823)

(subtract{-Int-} inst__Prelude_Num_Int

(fromInteger{-Int-} inst__Prelude_Num_Int 1)))

(fromEnum{-a-} d823)

default__enumFrom d834 x

= map{-Int a-} (toEnum{-a-} d834)

(enumFrom{-Int-} inst__Prelude_Enum_Int

(fromEnum{-a-} d834 x))

default__enumFromTo d848 x y

= map{-Int a-} (toEnum{-a-} d848)

(enumFromTo{-Int-} inst__Prelude_Enum_Int

(fromEnum{-a-} d848 x)

(fromEnum{-a-} d848 y))

default__enumFromThen d862 x y

= map{-Int a-} (toEnum{-a-} d862)

(enumFromThen{-Int-} inst__Prelude_Enum_Int

(fromEnum{-a-} d862 x)

(fromEnum{-a-} d862 y))

default__enumFromThenTo d879 x y z

= map{-Int a-} (toEnum{-a-} d879)

(enumFromThenTo{-Int-} inst__Prelude_Enum_Int

(fromEnum{-a-} d879 x)

(fromEnum{-a-} d879 y)

(fromEnum{-a-} d879 z))

default__toEnum d882

= error{-(Int -> a)-} "No default for method toEnum"

default__fromEnum d885

= error{-(a -> Int)-}

"No default for method fromEnum"

class Bounded a

where

minBound :: a

maxBound :: a

default__minBound d895

= error{-a-} "No default for method minBound"

default__maxBound d898

= error{-a-} "No default for method maxBound"

data () = () deriving (Eq, Ord, Show)

data (a, b) = (,) a b deriving (Show, Eq, Ord)

data (a, b, c)

= Prelude.(,,) a b c deriving (Show, Eq, Ord)

data (a, b, c, d)

= Prelude.(,,,) a b c d deriving (Show, Eq, Ord)

class (Num a, Ord a) => Real a

where toRational :: a -> Rational

default__toRational d902

= error{-(a -> Rational)-}

"No default for method toRational"

class (Real a, Enum a) => Integral a

where

quot,rem :: a -> a -> a

div,mod :: a -> a -> a

quotRem,divMod :: a -> a -> (a, a)

toInteger :: a -> Integer

default__quot d907

= error{-(a -> a -> a)-} "No default for method quot"

default__rem d910

= error{-(a -> a -> a)-} "No default for method rem"

default__div d913

= error{-(a -> a -> a)-} "No default for method div"

default__mod d916

= error{-(a -> a -> a)-} "No default for method mod"

default__quotRem d919

= error{-(a -> a -> (a, a))-}

"No default for method quotRem"

default__divMod d922

= error{-(a -> a -> (a, a))-}

"No default for method divMod"

default__toInteger d925

= error{-(a -> Integer)-}

"No default for method toInteger"

fromIntegral :: (Integral a, Num b) => a -> b

fromIntegral d939 d940

= (.){-Integer b a-} (fromInteger{-b-} d940)

(toInteger{-a-} d939)

even,odd :: Integral a => a -> Bool

even d951 n

= (==){-a-} d944

(rem{-a-} d951 n (fromInteger{-a-} d948 2))

(fromInteger{-a-} d948 0)

where

d948 = super1_Real{-a-} (super1_Integral{-a-} d951)

d944

= super1_Num{-a-}

(super1_Real{-a-} (super1_Integral{-a-} d951))

{-

d948 :: Num a

d944 :: Eq a

-}

odd d956 n = not (even{-a-} d956 n)

class (Real a, Fractional a) => RealFrac a

where

properFraction :: Integral b => a -> (b, a)

truncate,round :: Integral b => a -> b

ceiling,floor :: Integral b => a -> b

default__truncate d965 d966 x

= m

where

(m, _) = properFraction{-a b-} d965 d966 x

{-

m :: b

-}

default__round d1006 d1007 x

= let (n, r) = properFraction{-a b-} d1006 d1007 x

m = if (<){-a-} d977 r (fromInteger{-a-} d979 0)

then (-){-b-} d981 n (fromInteger{-b-} d981 1)

else (+){-b-} d981 n (fromInteger{-b-} d981 1)

{-

r :: a

n :: b

m :: b

-}

in case signum{-a-} d979

((-){-a-} d979 (abs{-a-} d979 r)

(fromRational{-a-} d995 1 % 2)) of

negate{-a-} d997 (fromInteger{-a-} d999 1) -> n

fromInteger{-a-} d1001 0

-> if even{-b-} d1007 n then n else m

fromInteger{-a-} d1005 1 -> m

where

d995 = super2_RealFrac{-a-} d1006

d981 = super1_Real{-b-} (super1_Integral{-b-} d1007)

d979 = super1_Real{-a-} (super1_RealFrac{-a-} d1006)

d977 = super2_Real{-a-} (super1_RealFrac{-a-} d1006)

{-

d995 :: Fractional a

d981 :: Num b

d979 :: Num a

d977 :: Ord a

-}

default__ceiling d1024 d1025 x

= if (>){-a-} d1017 r (fromInteger{-a-} d1019 0)

then (+){-b-} d1021 n (fromInteger{-b-} d1021 1)

else n

where

d1021 = super1_Real{-b-} (super1_Integral{-b-} d1025)

d1019 = super1_Real{-a-} (super1_RealFrac{-a-} d1024)

d1017 = super2_Real{-a-} (super1_RealFrac{-a-} d1024)

(n, r) = properFraction{-a b-} d1024 d1025 x

{-

d1021 :: Num b

d1019 :: Num a

d1017 :: Ord a

r :: a

n :: b

-}

default__floor d1042 d1043 x

= if (<){-a-} d1035 r (fromInteger{-a-} d1037 0)

then (-){-b-} d1039 n (fromInteger{-b-} d1039 1)

else n

where

d1039 = super1_Real{-b-} (super1_Integral{-b-} d1043)

d1037 = super1_Real{-a-} (super1_RealFrac{-a-} d1042)

d1035 = super2_Real{-a-} (super1_RealFrac{-a-} d1042)

(n, r) = properFraction{-a b-} d1042 d1043 x

{-

d1039 :: Num b

d1037 :: Num a

d1035 :: Ord a

r :: a

n :: b

-}

default__properFraction d1046 d1047

= error{-(a -> (b, a))-}

"No default for method properFraction"

data Btree a

= Empty | T a (Btree a) (Btree a) deriving Show

buildtree :: Ord a => [a] -> Btree a

buildtree d1069 [] = Empty{-a-}

buildtree d1069 ((:){-a-} x xs)

= insert{-a-} d1069 x (buildtree{-a-} d1069 xs)

insert :: Ord a => a -> (Btree a) -> Btree a

insert d1090 val Empty{-a-}

= T{-a-} val Empty{-a-} Empty{-a-}

insert d1090 val tree@(T{-a-} tval left right)

| (>){-a-} d1090 val tval =

T{-a-} tval left (insert{-a-} d1090 val right)

| otherwise =

T{-a-} tval (insert{-a-} d1090 val left) right

main :: Btree Int

main

= buildtree{-Int-} inst__Prelude_Ord_Int

[fromInteger{-Int-} inst__Prelude_Num_Int 3,

fromInteger{-Int-} inst__Prelude_Num_Int 1,

fromInteger{-Int-} inst__Prelude_Num_Int 2]

instance Eq Bool

where

(==) False False = True

(==) True True = True

(==) _ _ = False

(/=) = ($--/=){-Bool-} derived__Prelude_Eq_Bool

{-

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

-}

instance Ord Bool

where

super1_Ord

= super{-(Eq Bool)-} derived__Prelude_Eq_Bool

compare x y

= let cno False

= let t1114 :: Int

t1114 = fromInteger{-Int-} inst__Prelude_Num_Int 0

{- t1114 :: Int -}

in t1114

cno True = fromInteger{-Int-} inst__Prelude_Num_Int 1

{- cno :: Bool -> Int -}

in compare{-Int-} inst__Prelude_Ord_Int (cno x)

(cno y)

(<) = ($--<){-Bool-} derived__Prelude_Ord_Bool

(<=) = ($--<=){-Bool-} derived__Prelude_Ord_Bool

(>=) = ($-->=){-Bool-} derived__Prelude_Ord_Bool

(>) = ($-->){-Bool-} derived__Prelude_Ord_Bool

max = default__max{-Bool-} derived__Prelude_Ord_Bool

min = default__min{-Bool-} derived__Prelude_Ord_Bool

{-

super1_Ord :: Eq Bool

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

-}

instance Show Bool

where

showsPrec d False = showString "False"

showsPrec d True = showString "True"

show

= default__show{-Bool-} derived__Prelude_Show_Bool

showList

= default__showList{-Bool-}

derived__Prelude_Show_Bool

{-

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

-}

instance Eq Ordering

where

(==) LT LT = True

(==) EQ EQ = True

(==) GT GT = True

(==) _ _ = False

(/=)

= ($--/=){-Ordering-} derived__Prelude_Eq_Ordering

{-

(==) :: Ordering -> Ordering -> Bool

(/=) :: Ordering -> Ordering -> Bool

-}

instance Ord Ordering

where

super1_Ord

= super{-(Eq Ordering)-} derived__Prelude_Eq_Ordering

compare x y

= let cno LT

= let t1165 :: Int

t1165 = fromInteger{-Int-} inst__Prelude_Num_Int 0

{- t1165 :: Int -}

in t1165

cno EQ = fromInteger{-Int-} inst__Prelude_Num_Int 1

cno GT = fromInteger{-Int-} inst__Prelude_Num_Int 2

{- cno :: Ordering -> Int -}

in compare{-Int-} inst__Prelude_Ord_Int (cno x)

(cno y)

(<) = ($--<){-Ordering-}

derived__Prelude_Ord_Ordering

(<=)

= ($--<=){-Ordering-} derived__Prelude_Ord_Ordering

(>=)

= ($-->=){-Ordering-} derived__Prelude_Ord_Ordering

(>) = ($-->){-Ordering-}

derived__Prelude_Ord_Ordering

max = default__max{-Ordering-}

derived__Prelude_Ord_Ordering

min = default__min{-Ordering-}

derived__Prelude_Ord_Ordering

{-

super1_Ord :: Eq Ordering

compare :: Ordering -> Ordering -> Ordering

(<) :: Ordering -> Ordering -> Bool

(<=) :: Ordering -> Ordering -> Bool

(>=) :: Ordering -> Ordering -> Bool

(>) :: Ordering -> Ordering -> Bool

max :: Ordering -> Ordering -> Ordering

min :: Ordering -> Ordering -> Ordering

-}

instance Show Ordering

where

showsPrec d LT = showString "LT"

showsPrec d EQ = showString "EQ"

showsPrec d GT = showString "GT"

show

= default__show{-Ordering-}

derived__Prelude_Show_Ordering

showList

= default__showList{-Ordering-}

derived__Prelude_Show_Ordering

{-

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

-}

instance Eq a => Eq [a]

where

(==) d1221 []{-a-} []{-a-} = True

(==) d1221 ((:){-a-} x1 x2) ((:){-a-} y1 y2)

= (&&) ((==){-a-} d1221 x1 y1)

((==){-[a]-} d1217 x2 y2)

where

d1217 = derived__Prelude_Eq_34_65{-a-} d1221

{-

d1217 :: Eq [a]

-}

(==) d1221 _ _ = False

(/=) d1225

= ($--/=){-[a]-} d1224

where

d1224 = derived__Prelude_Eq_34_65{-a-} d1225

{-

d1224 :: Eq [a]

-}

{-

(==) :: forall a . (Eq a) => [a] -> [a] -> Bool

(/=) :: forall a . (Eq a) => [a] -> [a] -> Bool

-}

instance Ord a => Ord [a]

where

super1_Ord d1230

= super{-(Eq [a])-} d1229

where

d1231 = super1_Ord{-a-} d1230

d1229 = derived__Prelude_Eq_34_65{-a-} d1231

{-

d1231 :: Eq a

d1229 :: Eq [a]

-}

compare d1264 ((:){-a-} x1 x2) ((:){-a-} y1 y2)

= lexOrder (compare{-a-} d1264 x1 y1)

(compare{-[a]-} d1242 x2 y2)

where

d1242 = derived__Prelude_Ord_34_69{-a-} d1264

{-

d1242 :: Ord [a]

-}

compare d1264 x y

= let cno []{-t1255-}

= let t1248 :: Int

t1248 = fromInteger{-Int-} inst__Prelude_Num_Int 0

{- t1248 :: Int -}

in t1248

cno ((:){-t1255-} _ _)

= fromInteger{-Int-} inst__Prelude_Num_Int 1

{- cno :: forall a . [a] -> Int -}

in compare{-Int-} inst__Prelude_Ord_Int (cno{-a-} x)

(cno{-a-} y)

(<) d1268

= ($--<){-[a]-} d1267

where

d1267 = derived__Prelude_Ord_34_69{-a-} d1268

{-

d1267 :: Ord [a]

-}

(<=) d1273

= ($--<=){-[a]-} d1272

where

d1272 = derived__Prelude_Ord_34_69{-a-} d1273

{-

d1272 :: Ord [a]

-}

(>=) d1278

= ($-->=){-[a]-} d1277

where

d1277 = derived__Prelude_Ord_34_69{-a-} d1278

{-

d1277 :: Ord [a]

-}

(>) d1283

= ($-->){-[a]-} d1282

where

d1282 = derived__Prelude_Ord_34_69{-a-} d1283

{-

d1282 :: Ord [a]

-}

max d1288

= default__max{-[a]-} d1287

where

d1287 = derived__Prelude_Ord_34_69{-a-} d1288

{-

d1287 :: Ord [a]

-}

min d1293

= default__min{-[a]-} d1292

where

d1292 = derived__Prelude_Ord_34_69{-a-} d1293

{-

d1292 :: Ord [a]

-}

{-

super1_Ord :: forall a . (Ord a) => Eq [a]

compare ::

forall a . (Ord a) => [a] -> [a] -> Ordering

(<) :: forall a . (Ord a) => [a] -> [a] -> Bool

(<=) :: forall a . (Ord a) => [a] -> [a] -> Bool

(>=) :: forall a . (Ord a) => [a] -> [a] -> Bool

(>) :: forall a . (Ord a) => [a] -> [a] -> Bool

max :: forall a . (Ord a) => [a] -> [a] -> [a]

min :: forall a . (Ord a) => [a] -> [a] -> [a]

-}

instance Show a => Show [a]

where

showsPrec d1313 d []{-a-} = showString "[]"

showsPrec d1313 d ((:){-a-} x1 x2)

= showParenArg d

((.){-String String String-} (showString ":")

((.){-String String String-}

(showArgument{-a-} d1313 x1)

(showArgument{-[a]-} d1311 x2)))

where

d1311 = derived__Prelude_Show_34_59{-a-} d1313

{-

d1311 :: Show [a]

-}

show d1317

= default__show{-[a]-} d1316

where

d1316 = derived__Prelude_Show_34_59{-a-} d1317

{-

d1316 :: Show [a]

-}

showList d1322

= default__showList{-[a]-} d1321

where

d1321 = derived__Prelude_Show_34_59{-a-} d1322

{-

d1321 :: Show [a]

-}

{-

showsPrec ::

forall a . (Show a) => Int -> [a] -> ShowS

show :: forall a . (Show a) => [a] -> String

showList :: forall a . (Show a) => [[a]] -> ShowS

-}

instance Eq ()

where

(==) () () = True

(/=) = ($--/=){-()-} derived__Prelude_Eq_184_27

{-

(==) :: () -> () -> Bool

(/=) :: () -> () -> Bool

-}

instance Ord ()

where

super1_Ord

= super{-(Eq ())-} derived__Prelude_Eq_184_27

compare x y

= let cno ()

= let t1336 :: Int

t1336 = fromInteger{-Int-} inst__Prelude_Num_Int 0

{- t1336 :: Int -}

in t1336

{- cno :: () -> Int -}

in compare{-Int-} inst__Prelude_Ord_Int (cno x)

(cno y)

(<) = ($--<){-()-} derived__Prelude_Ord_184_31

(<=) = ($--<=){-()-} derived__Prelude_Ord_184_31

(>=) = ($-->=){-()-} derived__Prelude_Ord_184_31

(>) = ($-->){-()-} derived__Prelude_Ord_184_31

max = default__max{-()-} derived__Prelude_Ord_184_31

min = default__min{-()-} derived__Prelude_Ord_184_31

{-

super1_Ord :: Eq ()

compare :: () -> () -> Ordering

(<) :: () -> () -> Bool

(<=) :: () -> () -> Bool

(>=) :: () -> () -> Bool

(>) :: () -> () -> Bool

max :: () -> () -> ()

min :: () -> () -> ()

-}

instance Show ()

where

showsPrec d () = showString "()"

show

= default__show{-()-} derived__Prelude_Show_184_36

showList

= default__showList{-()-}

derived__Prelude_Show_184_36

{-

showsPrec :: Int -> () -> ShowS

show :: () -> String

showList :: [()] -> ShowS

-}

instance (Eq a, Eq b) => Eq (a, b)

where

(==) d1383 d1384 ((,){-a b-} x1 x2)

((,){-a b-} y1 y2)

= (&&) ((==){-a-} d1383 x1 y1)

((==){-b-} d1384 x2 y2)

(/=) d1388 d1389

= ($--/=){-(a, b)-} d1387

where

d1387 = derived__Prelude_Eq_188_20{-a b-} d1388 d1389

{-

d1387 :: Eq (a, b)

-}

{-

(==) ::

forall a b . (Eq a, Eq b) => (a, b) -> (a, b) -> Bool

(/=) ::

forall a b . (Eq a, Eq b) => (a, b) -> (a, b) -> Bool

-}

instance (Ord a, Ord b) => Ord (a, b)

where

super1_Ord d1395 d1396

= super{-(Eq (a, b))-} d1394

where

d1397 = super1_Ord{-a-} d1395

d1398 = super1_Ord{-b-} d1396

d1394 = derived__Prelude_Eq_188_20{-a b-} d1397 d1398

{-

d1397 :: Eq a

d1398 :: Eq b

d1394 :: Eq (a, b)

-}

compare d1412 d1413 ((,){-a b-} x1 x2)

((,){-a b-} y1 y2)

= lexOrder (compare{-a-} d1412 x1 y1)

(compare{-b-} d1413 x2 y2)

(<) d1417 d1418

= ($--<){-(a, b)-} d1416

where

d1416

= derived__Prelude_Ord_188_24{-a b-} d1417 d1418

{-

d1416 :: Ord (a, b)

-}

(<=) d1424 d1425

= ($--<=){-(a, b)-} d1423

where

d1423

= derived__Prelude_Ord_188_24{-a b-} d1424 d1425

{-

d1423 :: Ord (a, b)

-}

(>=) d1431 d1432

= ($-->=){-(a, b)-} d1430

where

d1430

= derived__Prelude_Ord_188_24{-a b-} d1431 d1432

{-

d1430 :: Ord (a, b)

-}

(>) d1438 d1439

= ($-->){-(a, b)-} d1437

where

d1437

= derived__Prelude_Ord_188_24{-a b-} d1438 d1439

{-

d1437 :: Ord (a, b)

-}

max d1445 d1446

= default__max{-(a, b)-} d1444

where

d1444

= derived__Prelude_Ord_188_24{-a b-} d1445 d1446

{-

d1444 :: Ord (a, b)

-}

min d1452 d1453

= default__min{-(a, b)-} d1451

where

d1451

= derived__Prelude_Ord_188_24{-a b-} d1452 d1453

{-

d1451 :: Ord (a, b)

-}

{-

super1_Ord ::

forall a b . (Ord a, Ord b) => Eq (a, b)

compare ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> Ordering

(<) ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> Bool

(<=) ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> Bool

(>=) ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> Bool

(>) ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> Bool

max ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> (a, b)

min ::

forall a b .

(Ord a, Ord b) => (a, b) -> (a, b) -> (a, b)

-}

instance (Show a, Show b) => Show (a, b)

where

showsPrec d1472 d1473 d ((,){-a b-} x1 x2)

= showParenArg d

((.){-String String String-} (showString "(,)")

((.){-String String String-}

(showArgument{-a-} d1472 x1)

(showArgument{-b-} d1473 x2)))

show d1477 d1478

= default__show{-(a, b)-} d1476

where

d1476

= derived__Prelude_Show_188_14{-a b-} d1477 d1478

{-

d1476 :: Show (a, b)

-}

showList d1484 d1485

= default__showList{-(a, b)-} d1483

where

d1483

= derived__Prelude_Show_188_14{-a b-} d1484 d1485

{-

d1483 :: Show (a, b)

-}

{-

showsPrec ::

forall a b .

(Show a, Show b) => Int -> (a, b) -> ShowS

show ::

forall a b . (Show a, Show b) => (a, b) -> String

showList ::

forall a b . (Show a, Show b) => [(a, b)] -> ShowS

-}

instance (Eq a, Eq b, Eq c) => Eq (a, b, c)

where

(==) d1507 d1508 d1509 ((,,){-a b c-} x1 x2 x3)

((,,){-a b c-} y1 y2 y3)

= (&&) ((==){-a-} d1507 x1 y1)

((&&) ((==){-b-} d1508 x2 y2)

((==){-c-} d1509 x3 y3))

(/=) d1513 d1514 d1515

= ($--/=){-(a, b, c)-} d1512

where

d1512

= derived__Prelude_Eq_192_20{-a b c-} d1513 d1514

d1515

{-

d1512 :: Eq (a, b, c)

-}

{-

(==) ::

forall a b c .

(Eq a, Eq b, Eq c) => (a, b, c) -> (a, b, c) -> Bool

(/=) ::

forall a b c .

(Eq a, Eq b, Eq c) => (a, b, c) -> (a, b, c) -> Bool

-}

instance (Ord a, Ord b, Ord c) => Ord (a, b, c)

where

super1_Ord d1522 d1523 d1524

= super{-(Eq (a, b, c))-} d1521

where

d1525 = super1_Ord{-a-} d1522

d1526 = super1_Ord{-b-} d1523

d1527 = super1_Ord{-c-} d1524

d1521

= derived__Prelude_Eq_192_20{-a b c-} d1525 d1526

d1527

{-

d1525 :: Eq a

d1526 :: Eq b

d1527 :: Eq c

d1521 :: Eq (a, b, c)

-}

compare d1547 d1548 d1549 ((,,){-a b c-} x1 x2 x3)

((,,){-a b c-} y1 y2 y3)

= lexOrder (compare{-a-} d1547 x1 y1)

(lexOrder (compare{-b-} d1548 x2 y2)

(compare{-c-} d1549 x3 y3))

(<) d1553 d1554 d1555

= ($--<){-(a, b, c)-} d1552

where

d1552

= derived__Prelude_Ord_192_24{-a b c-} d1553 d1554

d1555

{-

d1552 :: Ord (a, b, c)

-}

(<=) d1562 d1563 d1564

= ($--<=){-(a, b, c)-} d1561

where

d1561

= derived__Prelude_Ord_192_24{-a b c-} d1562 d1563

d1564

{-

d1561 :: Ord (a, b, c)

-}

(>=) d1571 d1572 d1573

= ($-->=){-(a, b, c)-} d1570

where

d1570

= derived__Prelude_Ord_192_24{-a b c-} d1571 d1572

d1573

{-

d1570 :: Ord (a, b, c)

-}

(>) d1580 d1581 d1582

= ($-->){-(a, b, c)-} d1579

where

d1579

= derived__Prelude_Ord_192_24{-a b c-} d1580 d1581

d1582

{-

d1579 :: Ord (a, b, c)

-}

max d1589 d1590 d1591

= default__max{-(a, b, c)-} d1588

where

d1588

= derived__Prelude_Ord_192_24{-a b c-} d1589 d1590

d1591

{-

d1588 :: Ord (a, b, c)

-}

min d1598 d1599 d1600

= default__min{-(a, b, c)-} d1597

where

d1597

= derived__Prelude_Ord_192_24{-a b c-} d1598 d1599

d1600

{-

d1597 :: Ord (a, b, c)

-}

{-

super1_Ord ::

forall a b c . (Ord a, Ord b, Ord c) => Eq (a, b, c)

compare ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> Ordering

(<) ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> Bool

(<=) ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> Bool

(>=) ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> Bool

(>) ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> Bool

max ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> (a, b, c)

min ::

forall a b c .

(Ord a, Ord b, Ord c) =>

(a, b, c) -> (a, b, c) -> (a, b, c)

-}

instance (Show a, Show b, Show c) => Show (a, b, c)

where

showsPrec d1627 d1628 d1629 d

((,,){-a b c-} x1 x2 x3)

= showParenArg d

((.){-String String String-} (showString "(,,)")

((.){-String String String-}

(showArgument{-a-} d1627 x1)

((.){-String String String-}

(showArgument{-b-} d1628 x2)

(showArgument{-c-} d1629 x3))))

show d1633 d1634 d1635

= default__show{-(a, b, c)-} d1632

where

d1632

= derived__Prelude_Show_192_14{-a b c-} d1633 d1634

d1635

{-

d1632 :: Show (a, b, c)

-}

showList d1642 d1643 d1644

= default__showList{-(a, b, c)-} d1641

where

d1641

= derived__Prelude_Show_192_14{-a b c-} d1642 d1643

d1644

{-

d1641 :: Show (a, b, c)

-}

{-

showsPrec ::

forall a b c .

(Show a, Show b, Show c) => Int -> (a, b, c) -> ShowS

show ::

forall a b c .

(Show a, Show b, Show c) => (a, b, c) -> String

showList ::

forall a b c .

(Show a, Show b, Show c) => [(a, b, c)] -> ShowS

-}

instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)

where

(==) d1673 d1674 d1675 d1676

((,,,){-a b c d-} x1 x2 x3 x4)

((,,,){-a b c d-} y1 y2 y3 y4)

= (&&) ((==){-a-} d1673 x1 y1)

((&&) ((==){-b-} d1674 x2 y2)

((&&) ((==){-c-} d1675 x3 y3)

((==){-d-} d1676 x4 y4)))

(/=) d1680 d1681 d1682 d1683

= ($--/=){-(a, b, c, d)-} d1679

where

d1679

= derived__Prelude_Eq_196_20{-a b c d-} d1680 d1681

d1682

d1683

{-

d1679 :: Eq (a, b, c, d)

-}

{-

(==) ::

forall a b c d .

(Eq a, Eq b, Eq c, Eq d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

(/=) ::

forall a b c d .

(Eq a, Eq b, Eq c, Eq d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

-}

instance (Ord a, Ord b, Ord c, Ord d) =>

Ord (a, b, c, d)

where

super1_Ord d1691 d1692 d1693 d1694

= super{-(Eq (a, b, c, d))-} d1690

where

d1695 = super1_Ord{-a-} d1691

d1696 = super1_Ord{-b-} d1692

d1697 = super1_Ord{-c-} d1693

d1698 = super1_Ord{-d-} d1694

d1690

= derived__Prelude_Eq_196_20{-a b c d-} d1695 d1696

d1697

d1698

{-

d1695 :: Eq a

d1696 :: Eq b

d1697 :: Eq c

d1698 :: Eq d

d1690 :: Eq (a, b, c, d)

-}

compare d1724 d1725 d1726 d1727

((,,,){-a b c d-} x1 x2 x3 x4)

((,,,){-a b c d-} y1 y2 y3 y4)

= lexOrder (compare{-a-} d1724 x1 y1)

(lexOrder (compare{-b-} d1725 x2 y2)

(lexOrder (compare{-c-} d1726 x3 y3)

(compare{-d-} d1727 x4 y4)))

(<) d1731 d1732 d1733 d1734

= ($--<){-(a, b, c, d)-} d1730

where

d1730

= derived__Prelude_Ord_196_24{-a b c d-} d1731

d1732

d1733

d1734

{-

d1730 :: Ord (a, b, c, d)

-}

(<=) d1742 d1743 d1744 d1745

= ($--<=){-(a, b, c, d)-} d1741

where

d1741

= derived__Prelude_Ord_196_24{-a b c d-} d1742

d1743

d1744

d1745

{-

d1741 :: Ord (a, b, c, d)

-}

(>=) d1753 d1754 d1755 d1756

= ($-->=){-(a, b, c, d)-} d1752

where

d1752

= derived__Prelude_Ord_196_24{-a b c d-} d1753

d1754

d1755

d1756

{-

d1752 :: Ord (a, b, c, d)

-}

(>) d1764 d1765 d1766 d1767

= ($-->){-(a, b, c, d)-} d1763

where

d1763

= derived__Prelude_Ord_196_24{-a b c d-} d1764

d1765

d1766

d1767

{-

d1763 :: Ord (a, b, c, d)

-}

max d1775 d1776 d1777 d1778

= default__max{-(a, b, c, d)-} d1774

where

d1774

= derived__Prelude_Ord_196_24{-a b c d-} d1775

d1776

d1777

d1778

{-

d1774 :: Ord (a, b, c, d)

-}

min d1786 d1787 d1788 d1789

= default__min{-(a, b, c, d)-} d1785

where

d1785

= derived__Prelude_Ord_196_24{-a b c d-} d1786

d1787

d1788

d1789

{-

d1785 :: Ord (a, b, c, d)

-}

{-

super1_Ord ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) => Eq (a, b, c, d)

compare ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> Ordering

(<) ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

(<=) ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

(>=) ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

(>) ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> Bool

max ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

min ::

forall a b c d .

(Ord a, Ord b, Ord c, Ord d) =>

(a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

-}

instance (Show a, Show b, Show c, Show d) =>

Show (a, b, c, d)

where

showsPrec d1824 d1825 d1826 d1827 d

((,,,){-a b c d-} x1 x2 x3 x4)

= showParenArg d

((.){-String String String-} (showString "(,,,)")

((.){-String String String-}

(showArgument{-a-} d1824 x1)

((.){-String String String-}

(showArgument{-b-} d1825 x2)

((.){-String String String-}

(showArgument{-c-} d1826 x3)

(showArgument{-d-} d1827 x4)))))

show d1831 d1832 d1833 d1834

= default__show{-(a, b, c, d)-} d1830

where

d1830

= derived__Prelude_Show_196_14{-a b c d-} d1831

d1832

d1833

d1834

{-

d1830 :: Show (a, b, c, d)

-}

showList d1842 d1843 d1844 d1845

= default__showList{-(a, b, c, d)-} d1841

where

d1841

= derived__Prelude_Show_196_14{-a b c d-} d1842

d1843

d1844

d1845

{-

d1841 :: Show (a, b, c, d)

-}

{-

showsPrec ::

forall a b c d .

(Show a, Show b, Show c, Show d) =>

Int -> (a, b, c, d) -> ShowS

show ::

forall a b c d .

(Show a, Show b, Show c, Show d) =>

(a, b, c, d) -> String

showList ::

forall a b c d .

(Show a, Show b, Show c, Show d) =>

[(a, b, c, d)] -> ShowS

-}

instance Show a => Show (Btree a)

where

showsPrec d1874 d Empty{-a-} = showString "Empty"

showsPrec d1874 d (T{-a-} x1 x2 x3)

= showParenArg d

((.){-String String String-} (showString "T")

((.){-String String String-}

(showArgument{-a-} d1874 x1)

((.){-String String String-}

(showArgument{-(Btree a)-} d1870 x2)

(showArgument{-(Btree a)-} d1870 x3))))

where

d1870 = derived__Prelude_Show_Btree{-a-} d1874

{-

d1870 :: Show (Btree a)

-}

show d1878

= default__show{-(Btree a)-} d1877

where

d1877 = derived__Prelude_Show_Btree{-a-} d1878

{-

d1877 :: Show (Btree a)

-}

showList d1883

= default__showList{-(Btree a)-} d1882

where

d1882 = derived__Prelude_Show_Btree{-a-} d1883

{-

d1882 :: Show (Btree a)

-}

{-

showsPrec ::

forall a . (Show a) => Int -> (Btree a) -> ShowS

show :: forall a . (Show a) => (Btree a) -> String

showList :: forall a . (Show a) => [Btree a] -> ShowS

-}