interface IO where {

{-# NEED #-}
instance Ix.Ix SeekMode;

{-# NEED #-}
instance Ix.Ix IOMode;

{-# NEED #-}
instance Prelude.Bounded SeekMode;

{-# NEED #-}
instance Prelude.Bounded IOMode;

{-# NEED #-}
instance Prelude.Enum DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Enum SeekMode;

{-# NEED #-}
instance Prelude.Enum IOMode;

{-# NEED #-}
instance Prelude.Ord BufferMode;

{-# NEED #-}
instance Prelude.Ord SeekMode;

{-# NEED #-}
instance Prelude.Ord IOMode;

{-# NEED #-}
instance Prelude.Read BufferMode;

{-# NEED #-}
instance Prelude.Read SeekMode;

{-# NEED #-}
instance Prelude.Read IOMode;

{-# NEED #-}
instance Prelude.Eq HandlePosn;

{-# NEED #-}
instance Prelude.Eq DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Eq BufferMode;

{-# NEED #-}
instance Prelude.Eq SeekMode;

{-# NEED #-}
instance Prelude.Eq IOMode;

{-# NEED #-}
instance Prelude.Eq Handle;

{-# NEED #-}
instance Prelude.Show HandlePosn;

{-# NEED #-}
instance Prelude.Show DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Show BufferMode;

{-# NEED #-}
instance Prelude.Show SeekMode;

{-# NEED #-}
instance Prelude.Show IOMode;

{-# NEED #-}
instance Prelude.Show Handle;

interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface ! Prelude
{-# NEED readIO #-}
readIO{-# 2 #-}::(Prelude.Read a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO a)))))));

{-# NEED print #-}
print{-# 2 #-}::(Prelude.Show a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED interact #-}
interact{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R Prelude.String)))) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED getContents #-}
getContents{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO [Prelude.Char]))));

{-# NEED putStr #-}
putStr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED userError #-}
userError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R Prelude.IOError))))));

{-# NEED putChar #-}
putChar{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Char) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED getChar #-}
getChar{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO Prelude.Char))));

{-# NEED putStrLn #-}
putStrLn{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED readLn #-}
readLn{-# 2 #-}::(Prelude.Read a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO a))));

{-# NEED ioError #-}
ioError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R (Prelude.IO a)))))));

{-# NEED catch #-}
catch{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R (Prelude.IO a))))) -> (Prelude.R (Prelude.IO a))))))))));

{-# NEED getLine #-}
getLine{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO Prelude.String))));

{-# NEED writeFile #-}
writeFile{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.FilePath) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED appendFile #-}
appendFile{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.FilePath) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED readFile #-}
readFile{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.FilePath) -> (Prelude.R (Prelude.IO Prelude.String)))))));
interface ! IO
{-# NEED try #-}
try{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.IO (Prelude.Either Prelude.IOError a))))))));

{-# NEED hPrint #-}
hPrint{-# 2 #-}::(Prelude.Show a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED bracket #-}
bracket{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO b))))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO c))))) -> (Prelude.R (Prelude.IO c)))))))))))));

{-# NEED hWaitForInput #-}
hWaitForInput{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO Prelude.Bool))))))))));

{-# NEED hReady #-}
hReady{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hLookAhead #-}
hLookAhead{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Char)))))));

{-# NEED hIsOpen #-}
hIsOpen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hIsClosed #-}
hIsClosed{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hIsReadable #-}
hIsReadable{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hIsWritable #-}
hIsWritable{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hIsSeekable #-}
hIsSeekable{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED hGetContents #-}
hGetContents{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.String)))))));

{-# NEED isAlreadyExistsError #-}
isAlreadyExistsError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isDoesNotExistError #-}
isDoesNotExistError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isAlreadyInUseError #-}
isAlreadyInUseError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isFullError #-}
isFullError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isIllegalOperation #-}
isIllegalOperation{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isPermissionError #-}
isPermissionError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED hPutStr #-}
hPutStr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED isUserError #-}
isUserError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED isEOFError #-}
isEOFError{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.Bool))))));

{-# NEED hPutChar #-}
hPutChar{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Char) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED hGetChar #-}
hGetChar{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Char)))))));

{-# NEED hSetPosn #-}
hSetPosn{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R HandlePosn) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED hGetPosn #-}
hGetPosn{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO HandlePosn)))))));

{-# NEED HandlePosn #-}
data HandlePosn;

{-# NEED stderr #-}
stderr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R Handle)));

{-# NEED stdin #-}
stdin{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R Handle)));

{-# NEED stdout #-}
stdout{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R Handle)));

{-# NEED hPutStrLn #-}
hPutStrLn{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO ()))))))))));

{-# NEED hSeek #-}
hSeek{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Trace -> ((Prelude.R SeekMode) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Integer) -> (Prelude.R (Prelude.IO ())))))))))))));

{-# NEED hFlush #-}
hFlush{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED ioeGetErrorString #-}
ioeGetErrorString{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R Prelude.String))))));

{-# NEED hFileSize #-}
hFileSize{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Integer)))))));

{-# NEED hClose #-}
hClose{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED hGetLine #-}
hGetLine{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.String)))))));

{-# NEED hGetFileName #-}
hGetFileName{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.Maybe Prelude.String)))))));

{-# NEED ioeGetFileName #-}
ioeGetFileName{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R (Prelude.Maybe Prelude.FilePath)))))));

{-# NEED openFile #-}
openFile{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.FilePath) -> (Prelude.R (Prelude.Trace -> ((Prelude.R IOMode) -> (Prelude.R (Prelude.IO Handle))))))))));
interface ! Prelude
{-# NEED FilePath #-}
type {-# 2 #-} FilePath = String;
interface ! IO
{-# NEED ioeGetHandle #-}
ioeGetHandle{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.IOError) -> (Prelude.R (Prelude.Maybe Handle)))))));
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface ! IO
{-# NEED {BufferMode NoBuffering LineBuffering BlockBuffering} #-}
data BufferMode
  = NoBuffering 
  | LineBuffering 
  | BlockBuffering (Prelude.R (Prelude.Maybe Prelude.Int));

{-# NEED {SeekMode AbsoluteSeek RelativeSeek SeekFromEnd} #-}
data SeekMode
  = AbsoluteSeek 
  | RelativeSeek 
  | SeekFromEnd ;

{-# NEED {IOMode ReadMode WriteMode AppendMode ReadWriteMode} #-}
data IOMode
  = ReadMode 
  | WriteMode 
  | AppendMode 
  | ReadWriteMode ;

{-# NEED bracket_ #-}
bracket_{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO b))))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO c)) -> (Prelude.R (Prelude.IO c)))))))))))));

{-# NEED hIsEOF #-}
hIsEOF{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Handle) -> (Prelude.R (Prelude.IO Prelude.Bool)))))));

{-# NEED Handle #-}
newtype {-#  #-} Handle;

{-# NEED isEOF #-}
isEOF{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO Prelude.Bool))));
interface ! Prelude
{-# NEED IO #-}
newtype {-#  #-} IO a;
}
