{-# LANGUAGE DuplicateRecordFields #-}

module Binja.Types.Core
  ( CSize (..),
    CBool (..),
    CInt (..),
    CUInt (..),
    CULLong (..),
    Word8,
    Word32,
    Word64,
    Int64,
    CChar,
    Ptr,
    FunPtr,
    nullFunPtr,
    nullPtr,
    CString,
    withCString,
    newCString,
    peekCString,
    GHC.ForeignPtr.ForeignPtr,
    (.&.),
    castWord32ToFloat,
    castWord64ToDouble,
    float2Double,
    newForeignPtr,
    pointerSize,
    peek,
    peekElemOff,
    alloca,
    castPtr,
    poke,
    peekArray,
    forM,
    when,
    finally,
    BNBinaryView,
    BNBinaryViewPtr,
    BNFileMetadata,
    BNFileMetaDataPtr,
    BNProgressFunction,
    BNProgressFunctionPtr,
    BNFunctionPtr,
    BNSymbolPtr,
    BNNameSpace,
    BNNameSpacePtr,
    BNStringRef (..),
    BNStringRefPtr,
    BNStringType (..),
    BNVariableSourceType (..),
    BNDataBufferPtr,
    BNReferenceSourcePtr,
    Binja.Types.Arch.BNArchPtr,
    DataVariable (..),
    Segment (..),
    Section (..),
    BNSegmentPtr,
    BNSectionPtr,
    BNTypeWithConfidence (..),
    BNBoolWithConfidence (..),
    BNTypeClass (..),
    BNTypePtr,
    BNMlilFunctionPtr,
    BNMlilSSAFunctionPtr,
    BNLlilFunctionPtr,
    BNBasicBlockPtr,
    BasicBlockMlilSSA (..),
    BNBasicBlockEdgePtr,
    BNBasicBlockEdge (..),
    BasicBlockEdge (..),
    BNBranchType,
    BNValueRangePtr,
    BNLookupTableEntryPtr,
    BNLowLevelILInstruction (..),
    BNLowLevelILOperation (..),
    BNMediumLevelILInstruction (..),
    BNMediumLevelILOperation (..),
    BNPossibleValueSet (..),
    BNVariable (..),
    BNSSAVariable (..),
    BNParameterVariablesWithConfidence (..),
    Binja.Types.Arch.Architecture,
    ParameterVars (..),
    AnalysisContext (..),
    FunctionContext (..),
    SSAVariableContext (..),
    ILIntrinsic (..),
    TargetMap,
    Function (..),
    FunctionList (..),
    SymbolList (..),
    SymbolType (..),
    SymbolBinding (..),
    Symbol (..),
    BNRegisterValueType (..),
    BNReferenceSource (..),
    Binja.Types.Core.alignmentS,
    Binja.Types.Arch.getArch,
    Binja.Types.Arch.getIntrinsic,
    CoreMediumLevelILInstruction (..),
    MediumLevelILSSAInstruction (..),
    Localcall (..),
    Constant (..),
    Comparison (..),
    Arithmetic (..),
    Terminal (..),
    Syscall (..),
    Tailcall (..),
    ControlFlow (..),
    Return (..),
    Load (..),
    Store (..),
    Memory (..),
    Carry (..),
    VariableInstruction (..),
    SetVar (..),
    RegisterStack (..),
    IntrinsicInstruction (..),
    MediumLevelILCallSsaRec (..),
    MediumLevelILCallOutputSsaRec (..),
    MediumLevelILVarOutputSsaRec (..),
    MediumLevelILVarOutputSsaFieldRec (..),
    MediumLevelILVarOutputAliasedRec (..),
    MediumLevelILVarOutputAliasedFieldRec (..),
    MediumLevelILConstPtrRec (..),
    MediumLevelILNopRec (..),
    MediumLevelILRetRec (..),
    MediumLevelILVarSsaRec (..),
    MediumLevelILSetVarSsaRec (..),
    MediumLevelILJumpRec (..),
    MediumLevelILJumpToRec (..),
    MediumLevelILTailcallSsaRec (..),
    MediumLevelILImportRec (..),
    MediumLevelILAddressOfRec (..),
    MediumLevelILAddressOfFieldRec (..),
    MediumLevelILPassByRefRec (..),
    MediumLevelILReturnByRefRec (..),
    MediumLevelILLoadSsaRec (..),
    MediumLevelILConstRec (..),
    MediumLevelILIfRec (..),
    MediumLevelILCmpERec (..),
    MediumLevelILCmpNeRec (..),
    MediumLevelILCmpSleRec (..),
    MediumLevelILCmpSltRec (..),
    MediumLevelILCmpUltRec (..),
    MediumLevelILCmpUleRec (..),
    MediumLevelILCmpSgeRec (..),
    MediumLevelILCmpUgeRec (..),
    MediumLevelILCmpSgtRec (..),
    MediumLevelILCmpUgtRec (..),
    MediumLevelILAndRec (..),
    MediumLevelILOrRec (..),
    MediumLevelILXorRec (..),
    MediumLevelILLslRec (..),
    MediumLevelILLsrRec (..),
    MediumLevelILAsrRec (..),
    MediumLevelILRolRec (..),
    MediumLevelILRorRec (..),
    MediumLevelILMulRec (..),
    MediumLevelILAdcRec (..),
    MediumLevelILSbbRec (..),
    MediumLevelILRlcRec (..),
    MediumLevelILRrcRec (..),
    MediumLevelILNoretRec (..),
    MediumLevelILStoreSsaRec (..),
    MediumLevelILSetVarAliasedRec (..),
    MediumLevelILSetVarSsaFieldRec (..),
    MediumLevelILSetVarFieldRec (..),
    MediumLevelILVarSsaFieldRec (..),
    MediumLevelILGotoRec (..),
    MediumLevelILAddRec (..),
    MediumLevelILSubRec (..),
    MediumLevelILMuluDpRec (..),
    MediumLevelILMulsDpRec (..),
    MediumLevelILDivuRec (..),
    MediumLevelILDivuDpRec (..),
    MediumLevelILDivsRec (..),
    MediumLevelILDivsDpRec (..),
    MediumLevelILModuRec (..),
    MediumLevelILModuDpRec (..),
    MediumLevelILModsRec (..),
    MediumLevelILModsDpRec (..),
    MediumLevelILNegRec (..),
    MediumLevelILNotRec (..),
    MediumLevelILCeilRec (..),
    MediumLevelILSxRec (..),
    MediumLevelILZxRec (..),
    MediumLevelILLowPartRec (..),
    MediumLevelILFsqrtRec (..),
    MediumLevelILFnegRec (..),
    MediumLevelILFabsRec (..),
    MediumLevelILFloatToIntRec (..),
    MediumLevelILIntToFloatRec (..),
    MediumLevelILFloatConvRec (..),
    MediumLevelILRoundToIntRec (..),
    MediumLevelILFloorRec (..),
    MediumLevelILFtruncRec (..),
    MediumLevelILIntrinsicSsaRec (..),
    MediumLevelILIntrinsicRec (..),
    MediumLevelILBoolToIntRec (..),
    MediumLevelILVarAliasedRec (..),
    MediumLevelILVarAliasedFieldRec (..),
    MediumLevelILSetVarAliasedFieldRec (..),
    MediumLevelILLoadStructSsaRec (..),
    MediumLevelILStoreStructSsaRec (..),
    MediumLevelILFcmpERec (..),
    MediumLevelILFcmpNeRec (..),
    MediumLevelILFcmpLtRec (..),
    MediumLevelILFcmpLeRec (..),
    MediumLevelILFcmpGeRec (..),
    MediumLevelILFcmpGtRec (..),
    MediumLevelILFcmpORec (..),
    MediumLevelILFcmpUoRec (..),
    MediumLevelILFaddRec (..),
    MediumLevelILFsubRec (..),
    MediumLevelILFmulRec (..),
    MediumLevelILFdivRec (..),
    MediumLevelILConstDataRec (..),
    MediumLevelILAddOverflowRec (..),
    MediumLevelILFloatConstRec (..),
    MediumLevelILTestBitRec (..),
    MediumLevelILSetVarSplitRec (..),
    MediumLevelILCallParamSsaRec (..),
    MediumLevelILCallParamRec (..),
    MediumLevelILSetVarRec (..),
    MediumLevelILAssertRec (..),
    MediumLevelILForceVerRec (..),
    MediumLevelILLoadRec (..),
    MediumLevelILLoadStructRec (..),
    MediumLevelILStoreRec (..),
    MediumLevelILStoreStructRec (..),
    MediumLevelILVarRec (..),
    MediumLevelILVarFieldRec (..),
    MediumLevelILVarSplitRec (..),
    MediumLevelILExternPtrRec (..),
    MediumLevelILRetHintRec (..),
    MediumLevelILBpRec (..),
    MediumLevelILTrapRec (..),
    MediumLevelILUndefRec (..),
    MediumLevelILUnimplRec (..),
    MediumLevelILUnimplMemRec (..),
    MediumLevelILSetVarSplitSsaRec (..),
    MediumLevelILVarSplitSsaRec (..),
    MediumLevelILAssertSsaRec (..),
    MediumLevelILForceVerSsaRec (..),
    MediumLevelILCallUntypedSsaRec (..),
    MediumLevelILSeparateParamListRec (..),
    MediumLevelILSharedParamSlotRec (..),
    MediumLevelILVarOutputRec (..),
    MediumLevelILVarOutputFieldRec (..),
    MediumLevelILStoreOutputRec (..),
    MediumLevelILSyscallRec (..),
    MediumLevelILSyscallUntypedRec (..),
    MediumLevelILTailcallRec (..),
    MediumLevelILTailcallUntypedRec (..),
    MediumLevelILFreeVarSlotRec (..),
    MediumLevelILSyscallSsaRec (..),
    MediumLevelILSyscallUntypedSsaRec (..),
    MediumLevelILTailcallUntypedSsaRec (..),
    MediumLevelILMemoryIntrinsicOutputSsaRec (..),
    MediumLevelILMemoryIntrinsicSsaRec (..),
    MediumLevelILFreeVarSlotSsaRec (..),
    MediumLevelILVarPhiRec (..),
    MediumLevelILMemPhiRec (..),
    MediumLevelILBlockToExpandRec (..),
    MediumLevelILBswapRec (..),
    MediumLevelILPopcntRec (..),
    MediumLevelILClzRec (..),
    MediumLevelILCtzRec (..),
    MediumLevelILRbitRec (..),
    MediumLevelILClsRec (..),
    MediumLevelILMinsRec (..),
    MediumLevelILMaxsRec (..),
    MediumLevelILMinuRec (..),
    MediumLevelILMaxuRec (..),
    MediumLevelILAbsRec (..),
    CFGContext (..),
  )
where

import Binja.Types.Arch (Architecture, BNArchPtr, Intrinsic, getArch, getIntrinsic)
import Control.Exception (finally)
import Control.Monad (forM, when)
import Data.Bits ((.&.))
import qualified Data.ByteString as BS
import Data.Int (Int64)
import Data.Map as Map
import Data.Set as Set
import Data.Word (Word32, Word64, Word8)
import Foreign
  ( Storable (alignment, peek, peekByteOff, poke, pokeByteOff, sizeOf),
    alloca,
    castPtr,
    peek,
    peekElemOff,
  )
import Foreign.C.String (CString, newCString, peekCString, withCString)
import Foreign.C.Types (CBool (..), CChar, CInt (..), CSize (..), CUInt (..), CULLong (..))
import Foreign.Concurrent (newForeignPtr)
import Foreign.Marshal.Array (peekArray)
import Foreign.Marshal.Utils (fromBool, toBool)
import Foreign.Ptr (FunPtr, Ptr, nullFunPtr, nullPtr)
import GHC.Float (castWord32ToFloat, castWord64ToDouble, float2Double)
import GHC.ForeignPtr (ForeignPtr)
import Numeric (showHex)

pointerSize :: Int
pointerSize :: Int
pointerSize = Ptr () -> Int
forall a. Storable a => a -> Int
sizeOf (Ptr ()
forall a. HasCallStack => a
undefined :: Ptr ())

alignmentS :: Int
alignmentS :: Int
alignmentS = Int
8

-------------------------
-- BinaryView Types
-------------------------

-- | Greatest common ancestor of all other binary ninja types
data BNBinaryView

type BNBinaryViewPtr = Ptr BNBinaryView

data BNFileMetadata

type BNFileMetaDataPtr = Ptr BNFileMetadata

-- | Type for the BNProgressFunction callback:
--   It is given a context pointer and two CSize values (e.g., current and total progress)
type BNProgressFunction = Ptr () -> CSize -> CSize -> IO CBool

type BNProgressFunctionPtr = FunPtr BNProgressFunction

data BNNameSpace

type BNNameSpacePtr = Ptr BNNameSpace

data BNFunction_

type BNFunctionPtr = Ptr BNFunction_

data BNSymbol_

type BNSymbolPtr = Ptr BNSymbol_

type BNStringRefPtr = Ptr BNStringRef

data BNDataBuffer_

type BNDataBufferPtr = Ptr BNDataBuffer_

data BNReferenceSource_

type BNReferenceSourcePtr = Ptr BNReferenceSource_

data BNMlilFunction_

type BNMlilFunctionPtr = Ptr BNMlilFunction_

data BNMlilSSAFunction_

type BNMlilSSAFunctionPtr = Ptr BNMlilSSAFunction_

data BNLlilFunction_

type BNLlilFunctionPtr = Ptr BNLlilFunction_

data BNValueRange_

type BNValueRangePtr = Ptr BNValueRange_

data BNLookupTableEntry_

type BNLookupTableEntryPtr = Ptr BNLookupTableEntry_

data BNBasicBlock_

type BNBasicBlockPtr = Ptr BNBasicBlock_

type BNBasicBlockEdgePtr = Ptr BNBasicBlockEdge

data BNType_

type BNTypePtr = Ptr BNType_

data BNSegment_

type BNSegmentPtr = Ptr BNSegment_

data BNSection_

type BNSectionPtr = Ptr BNSection_

type TargetMap = [(CULLong, CULLong)]

-- | Note: Algebra.Graph.Labelled provided by Alga will be expanded on its next release
-- Making it a good candidate to use for the CFGContext graph type.
data CFGContext = CFGContext
  { CFGContext -> Map BasicBlockMlilSSA (Set BasicBlockEdge)
graph :: Map.Map BasicBlockMlilSSA (Set.Set BasicBlockEdge),
    CFGContext -> BasicBlockMlilSSA
entry :: BasicBlockMlilSSA
  }
  deriving (Int -> CFGContext -> ShowS
[CFGContext] -> ShowS
CFGContext -> String
(Int -> CFGContext -> ShowS)
-> (CFGContext -> String)
-> ([CFGContext] -> ShowS)
-> Show CFGContext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFGContext -> ShowS
showsPrec :: Int -> CFGContext -> ShowS
$cshow :: CFGContext -> String
show :: CFGContext -> String
$cshowList :: [CFGContext] -> ShowS
showList :: [CFGContext] -> ShowS
Show)

-- | Central abstraction of Beluga
data AnalysisContext = AnalysisContext
  { -- | Binary View pointer which is the greatest common ancestor for all other types.
    AnalysisContext -> BNBinaryViewPtr
viewHandle :: BNBinaryViewPtr,
    -- | Path to file used to derive AnalysisContext
    AnalysisContext -> String
filename :: String,
    AnalysisContext -> [FunctionContext]
functions :: [FunctionContext],
    AnalysisContext -> Maybe FunctionContext
entryFunction :: Maybe FunctionContext,
    -- | List of entry functions like init_array, fini_array, TLS callbacks, etc.
    -- Exported functions in shared objects not included.
    AnalysisContext -> [FunctionContext]
entryFunctions :: [FunctionContext],
    AnalysisContext -> [Symbol]
symbols :: [Symbol],
    AnalysisContext -> [String]
strings :: [String],
    AnalysisContext -> [DataVariable]
dataVars :: [DataVariable],
    AnalysisContext -> Word64
imageBase :: Word64,
    AnalysisContext -> Word64
entryPoint :: Word64,
    AnalysisContext -> [Segment]
segments :: [Segment],
    AnalysisContext -> [Section]
sections :: [Section]
  }

-- | Higher level abstraction of a medium level IL SSA variant function
data FunctionContext = FunctionContext
  { FunctionContext -> BNMlilSSAFunctionPtr
handle :: BNMlilSSAFunctionPtr,
    -- | The start address for the function
    FunctionContext -> Word64
start :: Word64,
    FunctionContext -> Symbol
symbol :: Symbol,
    -- | True if the function was discovered via creation of a user function <https://api.binary.ninja/binaryninja.function-module.html#binaryninja.function.Function.auto python-doc>
    FunctionContext -> Bool
auto :: Bool,
    -- | Top level instructions
    FunctionContext -> [MediumLevelILSSAInstruction]
instructions :: [MediumLevelILSSAInstruction],
    -- | Mapping from SSA variables to their definition site (if exists) and use sites
    FunctionContext -> Map BNSSAVariable SSAVariableContext
ssaVars :: Map.Map BNSSAVariable SSAVariableContext,
    FunctionContext -> [BNVariable]
aliasedVars :: [BNVariable],
    FunctionContext -> ParameterVars
parameterVars :: ParameterVars,
    FunctionContext -> Architecture
architecture :: Binja.Types.Arch.Architecture,
    FunctionContext -> CFGContext
cfg :: CFGContext
  }
  deriving (Int -> FunctionContext -> ShowS
[FunctionContext] -> ShowS
FunctionContext -> String
(Int -> FunctionContext -> ShowS)
-> (FunctionContext -> String)
-> ([FunctionContext] -> ShowS)
-> Show FunctionContext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunctionContext -> ShowS
showsPrec :: Int -> FunctionContext -> ShowS
$cshow :: FunctionContext -> String
show :: FunctionContext -> String
$cshowList :: [FunctionContext] -> ShowS
showList :: [FunctionContext] -> ShowS
Show)

-- | Higher level abstract of ssa variable defintion site (if exists) and use sites
data SSAVariableContext = SSAVariableContext
  { SSAVariableContext -> Maybe MediumLevelILSSAInstruction
defSite :: Maybe MediumLevelILSSAInstruction,
    SSAVariableContext -> [MediumLevelILSSAInstruction]
useSites :: [MediumLevelILSSAInstruction]
  }
  deriving (Int -> SSAVariableContext -> ShowS
[SSAVariableContext] -> ShowS
SSAVariableContext -> String
(Int -> SSAVariableContext -> ShowS)
-> (SSAVariableContext -> String)
-> ([SSAVariableContext] -> ShowS)
-> Show SSAVariableContext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SSAVariableContext -> ShowS
showsPrec :: Int -> SSAVariableContext -> ShowS
$cshow :: SSAVariableContext -> String
show :: SSAVariableContext -> String
$cshowList :: [SSAVariableContext] -> ShowS
showList :: [SSAVariableContext] -> ShowS
Show)

data BNVariable = BNVariable
  { BNVariable -> BNVariableSourceType
varSourceType :: !BNVariableSourceType,
    BNVariable -> Word32
varIndex :: !Word32,
    BNVariable -> Int64
varStorage :: !Int64
  }
  deriving (BNVariable -> BNVariable -> Bool
(BNVariable -> BNVariable -> Bool)
-> (BNVariable -> BNVariable -> Bool) -> Eq BNVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNVariable -> BNVariable -> Bool
== :: BNVariable -> BNVariable -> Bool
$c/= :: BNVariable -> BNVariable -> Bool
/= :: BNVariable -> BNVariable -> Bool
Eq, Eq BNVariable
Eq BNVariable =>
(BNVariable -> BNVariable -> Ordering)
-> (BNVariable -> BNVariable -> Bool)
-> (BNVariable -> BNVariable -> Bool)
-> (BNVariable -> BNVariable -> Bool)
-> (BNVariable -> BNVariable -> Bool)
-> (BNVariable -> BNVariable -> BNVariable)
-> (BNVariable -> BNVariable -> BNVariable)
-> Ord BNVariable
BNVariable -> BNVariable -> Bool
BNVariable -> BNVariable -> Ordering
BNVariable -> BNVariable -> BNVariable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNVariable -> BNVariable -> Ordering
compare :: BNVariable -> BNVariable -> Ordering
$c< :: BNVariable -> BNVariable -> Bool
< :: BNVariable -> BNVariable -> Bool
$c<= :: BNVariable -> BNVariable -> Bool
<= :: BNVariable -> BNVariable -> Bool
$c> :: BNVariable -> BNVariable -> Bool
> :: BNVariable -> BNVariable -> Bool
$c>= :: BNVariable -> BNVariable -> Bool
>= :: BNVariable -> BNVariable -> Bool
$cmax :: BNVariable -> BNVariable -> BNVariable
max :: BNVariable -> BNVariable -> BNVariable
$cmin :: BNVariable -> BNVariable -> BNVariable
min :: BNVariable -> BNVariable -> BNVariable
Ord, Int -> BNVariable -> ShowS
[BNVariable] -> ShowS
BNVariable -> String
(Int -> BNVariable -> ShowS)
-> (BNVariable -> String)
-> ([BNVariable] -> ShowS)
-> Show BNVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNVariable -> ShowS
showsPrec :: Int -> BNVariable -> ShowS
$cshow :: BNVariable -> String
show :: BNVariable -> String
$cshowList :: [BNVariable] -> ShowS
showList :: [BNVariable] -> ShowS
Show)

instance Storable BNVariable where
  sizeOf :: BNVariable -> Int
sizeOf BNVariable
_ = Int
16
  alignment :: BNVariable -> Int
alignment BNVariable
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNVariable -> IO BNVariable
peek Ptr BNVariable
ptr = do
    t <- Ptr BNVariable -> Int -> IO Word8
forall b. Ptr b -> Int -> IO Word8
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNVariable
ptr Int
0 :: IO Word8
    r <- peekByteOff ptr 4 :: IO Word32
    s <- peekByteOff ptr 8 :: IO Int64
    pure (BNVariable (toEnum $ fromIntegral t) r s)
  poke :: Ptr BNVariable -> BNVariable -> IO ()
poke Ptr BNVariable
ptr (BNVariable BNVariableSourceType
t Word32
r Int64
s) = do
    Ptr BNVariable -> Int -> Word32 -> IO ()
forall b. Ptr b -> Int -> Word32 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNVariable
ptr Int
0 (Word32 -> IO ()) -> Word32 -> IO ()
forall a b. (a -> b) -> a -> b
$ (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (BNVariableSourceType -> Int
forall a. Enum a => a -> Int
fromEnum BNVariableSourceType
t) :: Word32)
    Ptr BNVariable -> Int -> Word32 -> IO ()
forall b. Ptr b -> Int -> Word32 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNVariable
ptr Int
4 Word32
r
    Ptr BNVariable -> Int -> Int64 -> IO ()
forall b. Ptr b -> Int -> Int64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNVariable
ptr Int
8 Int64
s

data BNSSAVariable = BNSSAVariable
  { BNSSAVariable -> BNVariable
rawVar :: BNVariable,
    BNSSAVariable -> Int
version :: Int
  }
  deriving (BNSSAVariable -> BNSSAVariable -> Bool
(BNSSAVariable -> BNSSAVariable -> Bool)
-> (BNSSAVariable -> BNSSAVariable -> Bool) -> Eq BNSSAVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNSSAVariable -> BNSSAVariable -> Bool
== :: BNSSAVariable -> BNSSAVariable -> Bool
$c/= :: BNSSAVariable -> BNSSAVariable -> Bool
/= :: BNSSAVariable -> BNSSAVariable -> Bool
Eq, Eq BNSSAVariable
Eq BNSSAVariable =>
(BNSSAVariable -> BNSSAVariable -> Ordering)
-> (BNSSAVariable -> BNSSAVariable -> Bool)
-> (BNSSAVariable -> BNSSAVariable -> Bool)
-> (BNSSAVariable -> BNSSAVariable -> Bool)
-> (BNSSAVariable -> BNSSAVariable -> Bool)
-> (BNSSAVariable -> BNSSAVariable -> BNSSAVariable)
-> (BNSSAVariable -> BNSSAVariable -> BNSSAVariable)
-> Ord BNSSAVariable
BNSSAVariable -> BNSSAVariable -> Bool
BNSSAVariable -> BNSSAVariable -> Ordering
BNSSAVariable -> BNSSAVariable -> BNSSAVariable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNSSAVariable -> BNSSAVariable -> Ordering
compare :: BNSSAVariable -> BNSSAVariable -> Ordering
$c< :: BNSSAVariable -> BNSSAVariable -> Bool
< :: BNSSAVariable -> BNSSAVariable -> Bool
$c<= :: BNSSAVariable -> BNSSAVariable -> Bool
<= :: BNSSAVariable -> BNSSAVariable -> Bool
$c> :: BNSSAVariable -> BNSSAVariable -> Bool
> :: BNSSAVariable -> BNSSAVariable -> Bool
$c>= :: BNSSAVariable -> BNSSAVariable -> Bool
>= :: BNSSAVariable -> BNSSAVariable -> Bool
$cmax :: BNSSAVariable -> BNSSAVariable -> BNSSAVariable
max :: BNSSAVariable -> BNSSAVariable -> BNSSAVariable
$cmin :: BNSSAVariable -> BNSSAVariable -> BNSSAVariable
min :: BNSSAVariable -> BNSSAVariable -> BNSSAVariable
Ord, Int -> BNSSAVariable -> ShowS
[BNSSAVariable] -> ShowS
BNSSAVariable -> String
(Int -> BNSSAVariable -> ShowS)
-> (BNSSAVariable -> String)
-> ([BNSSAVariable] -> ShowS)
-> Show BNSSAVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNSSAVariable -> ShowS
showsPrec :: Int -> BNSSAVariable -> ShowS
$cshow :: BNSSAVariable -> String
show :: BNSSAVariable -> String
$cshowList :: [BNSSAVariable] -> ShowS
showList :: [BNSSAVariable] -> ShowS
Show)

data BNParameterVariablesWithConfidence = BNParameterVariablesWithConfidence
  { BNParameterVariablesWithConfidence -> Ptr BNVariable
pvVarPtr :: !(Ptr BNVariable),
    BNParameterVariablesWithConfidence -> CSize
pvCount :: !CSize,
    BNParameterVariablesWithConfidence -> Word8
pvConfidence :: !Word8
  }
  deriving (Int -> BNParameterVariablesWithConfidence -> ShowS
[BNParameterVariablesWithConfidence] -> ShowS
BNParameterVariablesWithConfidence -> String
(Int -> BNParameterVariablesWithConfidence -> ShowS)
-> (BNParameterVariablesWithConfidence -> String)
-> ([BNParameterVariablesWithConfidence] -> ShowS)
-> Show BNParameterVariablesWithConfidence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNParameterVariablesWithConfidence -> ShowS
showsPrec :: Int -> BNParameterVariablesWithConfidence -> ShowS
$cshow :: BNParameterVariablesWithConfidence -> String
show :: BNParameterVariablesWithConfidence -> String
$cshowList :: [BNParameterVariablesWithConfidence] -> ShowS
showList :: [BNParameterVariablesWithConfidence] -> ShowS
Show)

data ParameterVars = ParameterVars
  { ParameterVars -> [BNVariable]
vars :: [BNVariable],
    ParameterVars -> Int
confidence :: Int
  }
  deriving (Int -> ParameterVars -> ShowS
[ParameterVars] -> ShowS
ParameterVars -> String
(Int -> ParameterVars -> ShowS)
-> (ParameterVars -> String)
-> ([ParameterVars] -> ShowS)
-> Show ParameterVars
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParameterVars -> ShowS
showsPrec :: Int -> ParameterVars -> ShowS
$cshow :: ParameterVars -> String
show :: ParameterVars -> String
$cshowList :: [ParameterVars] -> ShowS
showList :: [ParameterVars] -> ShowS
Show)

instance Storable BNParameterVariablesWithConfidence where
  sizeOf :: BNParameterVariablesWithConfidence -> Int
sizeOf BNParameterVariablesWithConfidence
_ = Int
24
  alignment :: BNParameterVariablesWithConfidence -> Int
alignment BNParameterVariablesWithConfidence
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNParameterVariablesWithConfidence
-> IO BNParameterVariablesWithConfidence
peek Ptr BNParameterVariablesWithConfidence
ptr = do
    varPtr' <- Ptr BNParameterVariablesWithConfidence
-> Int -> IO (Ptr BNVariable)
forall b. Ptr b -> Int -> IO (Ptr BNVariable)
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNParameterVariablesWithConfidence
ptr Int
0 :: IO (Ptr BNVariable)
    count' <- peekByteOff ptr 8 :: IO CSize
    confidence' <- peekByteOff ptr 16 :: IO Word8
    pure $ BNParameterVariablesWithConfidence varPtr' count' confidence'
  poke :: Ptr BNParameterVariablesWithConfidence
-> BNParameterVariablesWithConfidence -> IO ()
poke Ptr BNParameterVariablesWithConfidence
ptr (BNParameterVariablesWithConfidence Ptr BNVariable
varPtr' CSize
count' Word8
confidence') = do
    Ptr BNParameterVariablesWithConfidence
-> Int -> Ptr BNVariable -> IO ()
forall b. Ptr b -> Int -> Ptr BNVariable -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNParameterVariablesWithConfidence
ptr Int
0 Ptr BNVariable
varPtr'
    Ptr BNParameterVariablesWithConfidence -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNParameterVariablesWithConfidence
ptr Int
8 CSize
count'
    Ptr BNParameterVariablesWithConfidence -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNParameterVariablesWithConfidence
ptr Int
16 Word8
confidence'

data BNVariableSourceType
  = StackVariableSourceType
  | RegisterVariableSourceType
  | FlagVariableSourceType
  deriving (BNVariableSourceType -> BNVariableSourceType -> Bool
(BNVariableSourceType -> BNVariableSourceType -> Bool)
-> (BNVariableSourceType -> BNVariableSourceType -> Bool)
-> Eq BNVariableSourceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNVariableSourceType -> BNVariableSourceType -> Bool
== :: BNVariableSourceType -> BNVariableSourceType -> Bool
$c/= :: BNVariableSourceType -> BNVariableSourceType -> Bool
/= :: BNVariableSourceType -> BNVariableSourceType -> Bool
Eq, Eq BNVariableSourceType
Eq BNVariableSourceType =>
(BNVariableSourceType -> BNVariableSourceType -> Ordering)
-> (BNVariableSourceType -> BNVariableSourceType -> Bool)
-> (BNVariableSourceType -> BNVariableSourceType -> Bool)
-> (BNVariableSourceType -> BNVariableSourceType -> Bool)
-> (BNVariableSourceType -> BNVariableSourceType -> Bool)
-> (BNVariableSourceType
    -> BNVariableSourceType -> BNVariableSourceType)
-> (BNVariableSourceType
    -> BNVariableSourceType -> BNVariableSourceType)
-> Ord BNVariableSourceType
BNVariableSourceType -> BNVariableSourceType -> Bool
BNVariableSourceType -> BNVariableSourceType -> Ordering
BNVariableSourceType
-> BNVariableSourceType -> BNVariableSourceType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNVariableSourceType -> BNVariableSourceType -> Ordering
compare :: BNVariableSourceType -> BNVariableSourceType -> Ordering
$c< :: BNVariableSourceType -> BNVariableSourceType -> Bool
< :: BNVariableSourceType -> BNVariableSourceType -> Bool
$c<= :: BNVariableSourceType -> BNVariableSourceType -> Bool
<= :: BNVariableSourceType -> BNVariableSourceType -> Bool
$c> :: BNVariableSourceType -> BNVariableSourceType -> Bool
> :: BNVariableSourceType -> BNVariableSourceType -> Bool
$c>= :: BNVariableSourceType -> BNVariableSourceType -> Bool
>= :: BNVariableSourceType -> BNVariableSourceType -> Bool
$cmax :: BNVariableSourceType
-> BNVariableSourceType -> BNVariableSourceType
max :: BNVariableSourceType
-> BNVariableSourceType -> BNVariableSourceType
$cmin :: BNVariableSourceType
-> BNVariableSourceType -> BNVariableSourceType
min :: BNVariableSourceType
-> BNVariableSourceType -> BNVariableSourceType
Ord, Int -> BNVariableSourceType -> ShowS
[BNVariableSourceType] -> ShowS
BNVariableSourceType -> String
(Int -> BNVariableSourceType -> ShowS)
-> (BNVariableSourceType -> String)
-> ([BNVariableSourceType] -> ShowS)
-> Show BNVariableSourceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNVariableSourceType -> ShowS
showsPrec :: Int -> BNVariableSourceType -> ShowS
$cshow :: BNVariableSourceType -> String
show :: BNVariableSourceType -> String
$cshowList :: [BNVariableSourceType] -> ShowS
showList :: [BNVariableSourceType] -> ShowS
Show, Int -> BNVariableSourceType
BNVariableSourceType -> Int
BNVariableSourceType -> [BNVariableSourceType]
BNVariableSourceType -> BNVariableSourceType
BNVariableSourceType
-> BNVariableSourceType -> [BNVariableSourceType]
BNVariableSourceType
-> BNVariableSourceType
-> BNVariableSourceType
-> [BNVariableSourceType]
(BNVariableSourceType -> BNVariableSourceType)
-> (BNVariableSourceType -> BNVariableSourceType)
-> (Int -> BNVariableSourceType)
-> (BNVariableSourceType -> Int)
-> (BNVariableSourceType -> [BNVariableSourceType])
-> (BNVariableSourceType
    -> BNVariableSourceType -> [BNVariableSourceType])
-> (BNVariableSourceType
    -> BNVariableSourceType -> [BNVariableSourceType])
-> (BNVariableSourceType
    -> BNVariableSourceType
    -> BNVariableSourceType
    -> [BNVariableSourceType])
-> Enum BNVariableSourceType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNVariableSourceType -> BNVariableSourceType
succ :: BNVariableSourceType -> BNVariableSourceType
$cpred :: BNVariableSourceType -> BNVariableSourceType
pred :: BNVariableSourceType -> BNVariableSourceType
$ctoEnum :: Int -> BNVariableSourceType
toEnum :: Int -> BNVariableSourceType
$cfromEnum :: BNVariableSourceType -> Int
fromEnum :: BNVariableSourceType -> Int
$cenumFrom :: BNVariableSourceType -> [BNVariableSourceType]
enumFrom :: BNVariableSourceType -> [BNVariableSourceType]
$cenumFromThen :: BNVariableSourceType
-> BNVariableSourceType -> [BNVariableSourceType]
enumFromThen :: BNVariableSourceType
-> BNVariableSourceType -> [BNVariableSourceType]
$cenumFromTo :: BNVariableSourceType
-> BNVariableSourceType -> [BNVariableSourceType]
enumFromTo :: BNVariableSourceType
-> BNVariableSourceType -> [BNVariableSourceType]
$cenumFromThenTo :: BNVariableSourceType
-> BNVariableSourceType
-> BNVariableSourceType
-> [BNVariableSourceType]
enumFromThenTo :: BNVariableSourceType
-> BNVariableSourceType
-> BNVariableSourceType
-> [BNVariableSourceType]
Enum)

data ILIntrinsic = ILIntrinsic
  { ILIntrinsic -> CSize
index :: !CSize,
    ILIntrinsic -> BNArchPtr
archHandle :: !BNArchPtr,
    ILIntrinsic -> Architecture
arch :: Binja.Types.Arch.Architecture,
    ILIntrinsic -> Intrinsic
intrinsic :: Binja.Types.Arch.Intrinsic
  }
  deriving (Int -> ILIntrinsic -> ShowS
[ILIntrinsic] -> ShowS
ILIntrinsic -> String
(Int -> ILIntrinsic -> ShowS)
-> (ILIntrinsic -> String)
-> ([ILIntrinsic] -> ShowS)
-> Show ILIntrinsic
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ILIntrinsic -> ShowS
showsPrec :: Int -> ILIntrinsic -> ShowS
$cshow :: ILIntrinsic -> String
show :: ILIntrinsic -> String
$cshowList :: [ILIntrinsic] -> ShowS
showList :: [ILIntrinsic] -> ShowS
Show, ILIntrinsic -> ILIntrinsic -> Bool
(ILIntrinsic -> ILIntrinsic -> Bool)
-> (ILIntrinsic -> ILIntrinsic -> Bool) -> Eq ILIntrinsic
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ILIntrinsic -> ILIntrinsic -> Bool
== :: ILIntrinsic -> ILIntrinsic -> Bool
$c/= :: ILIntrinsic -> ILIntrinsic -> Bool
/= :: ILIntrinsic -> ILIntrinsic -> Bool
Eq, Eq ILIntrinsic
Eq ILIntrinsic =>
(ILIntrinsic -> ILIntrinsic -> Ordering)
-> (ILIntrinsic -> ILIntrinsic -> Bool)
-> (ILIntrinsic -> ILIntrinsic -> Bool)
-> (ILIntrinsic -> ILIntrinsic -> Bool)
-> (ILIntrinsic -> ILIntrinsic -> Bool)
-> (ILIntrinsic -> ILIntrinsic -> ILIntrinsic)
-> (ILIntrinsic -> ILIntrinsic -> ILIntrinsic)
-> Ord ILIntrinsic
ILIntrinsic -> ILIntrinsic -> Bool
ILIntrinsic -> ILIntrinsic -> Ordering
ILIntrinsic -> ILIntrinsic -> ILIntrinsic
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ILIntrinsic -> ILIntrinsic -> Ordering
compare :: ILIntrinsic -> ILIntrinsic -> Ordering
$c< :: ILIntrinsic -> ILIntrinsic -> Bool
< :: ILIntrinsic -> ILIntrinsic -> Bool
$c<= :: ILIntrinsic -> ILIntrinsic -> Bool
<= :: ILIntrinsic -> ILIntrinsic -> Bool
$c> :: ILIntrinsic -> ILIntrinsic -> Bool
> :: ILIntrinsic -> ILIntrinsic -> Bool
$c>= :: ILIntrinsic -> ILIntrinsic -> Bool
>= :: ILIntrinsic -> ILIntrinsic -> Bool
$cmax :: ILIntrinsic -> ILIntrinsic -> ILIntrinsic
max :: ILIntrinsic -> ILIntrinsic -> ILIntrinsic
$cmin :: ILIntrinsic -> ILIntrinsic -> ILIntrinsic
min :: ILIntrinsic -> ILIntrinsic -> ILIntrinsic
Ord)

data BNBranchType
  = UnconditionalBranch
  | FalseBranch
  | TrueBranch
  | CallDestination
  | FunctionReturn
  | SystemCall
  | IndirectBranch
  | ExceptionBranch
  | UnresolvedBranch
  | UserDefinedBranch
  deriving (Int -> BNBranchType -> ShowS
[BNBranchType] -> ShowS
BNBranchType -> String
(Int -> BNBranchType -> ShowS)
-> (BNBranchType -> String)
-> ([BNBranchType] -> ShowS)
-> Show BNBranchType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNBranchType -> ShowS
showsPrec :: Int -> BNBranchType -> ShowS
$cshow :: BNBranchType -> String
show :: BNBranchType -> String
$cshowList :: [BNBranchType] -> ShowS
showList :: [BNBranchType] -> ShowS
Show, BNBranchType -> BNBranchType -> Bool
(BNBranchType -> BNBranchType -> Bool)
-> (BNBranchType -> BNBranchType -> Bool) -> Eq BNBranchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNBranchType -> BNBranchType -> Bool
== :: BNBranchType -> BNBranchType -> Bool
$c/= :: BNBranchType -> BNBranchType -> Bool
/= :: BNBranchType -> BNBranchType -> Bool
Eq, Eq BNBranchType
Eq BNBranchType =>
(BNBranchType -> BNBranchType -> Ordering)
-> (BNBranchType -> BNBranchType -> Bool)
-> (BNBranchType -> BNBranchType -> Bool)
-> (BNBranchType -> BNBranchType -> Bool)
-> (BNBranchType -> BNBranchType -> Bool)
-> (BNBranchType -> BNBranchType -> BNBranchType)
-> (BNBranchType -> BNBranchType -> BNBranchType)
-> Ord BNBranchType
BNBranchType -> BNBranchType -> Bool
BNBranchType -> BNBranchType -> Ordering
BNBranchType -> BNBranchType -> BNBranchType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNBranchType -> BNBranchType -> Ordering
compare :: BNBranchType -> BNBranchType -> Ordering
$c< :: BNBranchType -> BNBranchType -> Bool
< :: BNBranchType -> BNBranchType -> Bool
$c<= :: BNBranchType -> BNBranchType -> Bool
<= :: BNBranchType -> BNBranchType -> Bool
$c> :: BNBranchType -> BNBranchType -> Bool
> :: BNBranchType -> BNBranchType -> Bool
$c>= :: BNBranchType -> BNBranchType -> Bool
>= :: BNBranchType -> BNBranchType -> Bool
$cmax :: BNBranchType -> BNBranchType -> BNBranchType
max :: BNBranchType -> BNBranchType -> BNBranchType
$cmin :: BNBranchType -> BNBranchType -> BNBranchType
min :: BNBranchType -> BNBranchType -> BNBranchType
Ord)

instance Enum BNBranchType where
  fromEnum :: BNBranchType -> Int
fromEnum BNBranchType
UnconditionalBranch = Int
0
  fromEnum BNBranchType
FalseBranch = Int
1
  fromEnum BNBranchType
TrueBranch = Int
2
  fromEnum BNBranchType
CallDestination = Int
3
  fromEnum BNBranchType
FunctionReturn = Int
4
  fromEnum BNBranchType
SystemCall = Int
5
  fromEnum BNBranchType
IndirectBranch = Int
6
  fromEnum BNBranchType
ExceptionBranch = Int
7
  fromEnum BNBranchType
UnresolvedBranch = Int
127
  fromEnum BNBranchType
UserDefinedBranch = Int
128

  toEnum :: Int -> BNBranchType
toEnum Int
0 = BNBranchType
UnconditionalBranch
  toEnum Int
1 = BNBranchType
FalseBranch
  toEnum Int
2 = BNBranchType
TrueBranch
  toEnum Int
3 = BNBranchType
CallDestination
  toEnum Int
4 = BNBranchType
FunctionReturn
  toEnum Int
5 = BNBranchType
SystemCall
  toEnum Int
6 = BNBranchType
IndirectBranch
  toEnum Int
7 = BNBranchType
ExceptionBranch
  toEnum Int
127 = BNBranchType
UnresolvedBranch
  toEnum Int
128 = BNBranchType
UserDefinedBranch
  toEnum Int
n = String -> BNBranchType
forall a. HasCallStack => String -> a
error (String -> BNBranchType) -> String -> BNBranchType
forall a b. (a -> b) -> a -> b
$ String
"BNRegisterValueType.toEnum: invalid tag " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n

data BNBasicBlockEdge = BNBasicBlockEdge
  { BNBasicBlockEdge -> BNBranchType
ty :: !BNBranchType,
    BNBasicBlockEdge -> BNBasicBlockPtr
target :: !BNBasicBlockPtr,
    BNBasicBlockEdge -> CBool
backEdge :: !CBool,
    BNBasicBlockEdge -> CBool
fallThrough :: !CBool
  }
  deriving (Int -> BNBasicBlockEdge -> ShowS
[BNBasicBlockEdge] -> ShowS
BNBasicBlockEdge -> String
(Int -> BNBasicBlockEdge -> ShowS)
-> (BNBasicBlockEdge -> String)
-> ([BNBasicBlockEdge] -> ShowS)
-> Show BNBasicBlockEdge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNBasicBlockEdge -> ShowS
showsPrec :: Int -> BNBasicBlockEdge -> ShowS
$cshow :: BNBasicBlockEdge -> String
show :: BNBasicBlockEdge -> String
$cshowList :: [BNBasicBlockEdge] -> ShowS
showList :: [BNBasicBlockEdge] -> ShowS
Show, BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
(BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> Eq BNBasicBlockEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
== :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
$c/= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
/= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
Eq, Eq BNBasicBlockEdge
Eq BNBasicBlockEdge =>
(BNBasicBlockEdge -> BNBasicBlockEdge -> Ordering)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> Bool)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge)
-> (BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge)
-> Ord BNBasicBlockEdge
BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
BNBasicBlockEdge -> BNBasicBlockEdge -> Ordering
BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNBasicBlockEdge -> BNBasicBlockEdge -> Ordering
compare :: BNBasicBlockEdge -> BNBasicBlockEdge -> Ordering
$c< :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
< :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
$c<= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
<= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
$c> :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
> :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
$c>= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
>= :: BNBasicBlockEdge -> BNBasicBlockEdge -> Bool
$cmax :: BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge
max :: BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge
$cmin :: BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge
min :: BNBasicBlockEdge -> BNBasicBlockEdge -> BNBasicBlockEdge
Ord)

data BasicBlockEdge = BasicBlockEdge
  { BasicBlockEdge -> BNBranchType
ty :: BNBranchType,
    BasicBlockEdge -> BasicBlockMlilSSA
target :: BasicBlockMlilSSA,
    BasicBlockEdge -> Bool
backEdge :: Bool,
    -- | Whether this edge targets to a node whose control flow can eventually flow back through the source node of this edge.
    BasicBlockEdge -> Bool
fallThrough :: Bool
  }
  deriving (Int -> BasicBlockEdge -> ShowS
[BasicBlockEdge] -> ShowS
BasicBlockEdge -> String
(Int -> BasicBlockEdge -> ShowS)
-> (BasicBlockEdge -> String)
-> ([BasicBlockEdge] -> ShowS)
-> Show BasicBlockEdge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BasicBlockEdge -> ShowS
showsPrec :: Int -> BasicBlockEdge -> ShowS
$cshow :: BasicBlockEdge -> String
show :: BasicBlockEdge -> String
$cshowList :: [BasicBlockEdge] -> ShowS
showList :: [BasicBlockEdge] -> ShowS
Show, BasicBlockEdge -> BasicBlockEdge -> Bool
(BasicBlockEdge -> BasicBlockEdge -> Bool)
-> (BasicBlockEdge -> BasicBlockEdge -> Bool) -> Eq BasicBlockEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BasicBlockEdge -> BasicBlockEdge -> Bool
== :: BasicBlockEdge -> BasicBlockEdge -> Bool
$c/= :: BasicBlockEdge -> BasicBlockEdge -> Bool
/= :: BasicBlockEdge -> BasicBlockEdge -> Bool
Eq, Eq BasicBlockEdge
Eq BasicBlockEdge =>
(BasicBlockEdge -> BasicBlockEdge -> Ordering)
-> (BasicBlockEdge -> BasicBlockEdge -> Bool)
-> (BasicBlockEdge -> BasicBlockEdge -> Bool)
-> (BasicBlockEdge -> BasicBlockEdge -> Bool)
-> (BasicBlockEdge -> BasicBlockEdge -> Bool)
-> (BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge)
-> (BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge)
-> Ord BasicBlockEdge
BasicBlockEdge -> BasicBlockEdge -> Bool
BasicBlockEdge -> BasicBlockEdge -> Ordering
BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BasicBlockEdge -> BasicBlockEdge -> Ordering
compare :: BasicBlockEdge -> BasicBlockEdge -> Ordering
$c< :: BasicBlockEdge -> BasicBlockEdge -> Bool
< :: BasicBlockEdge -> BasicBlockEdge -> Bool
$c<= :: BasicBlockEdge -> BasicBlockEdge -> Bool
<= :: BasicBlockEdge -> BasicBlockEdge -> Bool
$c> :: BasicBlockEdge -> BasicBlockEdge -> Bool
> :: BasicBlockEdge -> BasicBlockEdge -> Bool
$c>= :: BasicBlockEdge -> BasicBlockEdge -> Bool
>= :: BasicBlockEdge -> BasicBlockEdge -> Bool
$cmax :: BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge
max :: BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge
$cmin :: BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge
min :: BasicBlockEdge -> BasicBlockEdge -> BasicBlockEdge
Ord)

data BasicBlockMlilSSA = BasicBlockMlilSSA
  { BasicBlockMlilSSA -> BNBasicBlockPtr
handle :: !BNBasicBlockPtr,
    BasicBlockMlilSSA -> CSize
start :: !CSize,
    BasicBlockMlilSSA -> [MediumLevelILSSAInstruction]
instructions :: [MediumLevelILSSAInstruction],
    BasicBlockMlilSSA -> Bool
canExit :: !Bool,
    BasicBlockMlilSSA -> Bool
hasInvalidInstructions :: !Bool
  }
  deriving (Int -> BasicBlockMlilSSA -> ShowS
[BasicBlockMlilSSA] -> ShowS
BasicBlockMlilSSA -> String
(Int -> BasicBlockMlilSSA -> ShowS)
-> (BasicBlockMlilSSA -> String)
-> ([BasicBlockMlilSSA] -> ShowS)
-> Show BasicBlockMlilSSA
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BasicBlockMlilSSA -> ShowS
showsPrec :: Int -> BasicBlockMlilSSA -> ShowS
$cshow :: BasicBlockMlilSSA -> String
show :: BasicBlockMlilSSA -> String
$cshowList :: [BasicBlockMlilSSA] -> ShowS
showList :: [BasicBlockMlilSSA] -> ShowS
Show, BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
(BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> Eq BasicBlockMlilSSA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
== :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
$c/= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
/= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
Eq, Eq BasicBlockMlilSSA
Eq BasicBlockMlilSSA =>
(BasicBlockMlilSSA -> BasicBlockMlilSSA -> Ordering)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA)
-> (BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA)
-> Ord BasicBlockMlilSSA
BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
BasicBlockMlilSSA -> BasicBlockMlilSSA -> Ordering
BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Ordering
compare :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Ordering
$c< :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
< :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
$c<= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
<= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
$c> :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
> :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
$c>= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
>= :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> Bool
$cmax :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA
max :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA
$cmin :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA
min :: BasicBlockMlilSSA -> BasicBlockMlilSSA -> BasicBlockMlilSSA
Ord)

instance Storable BNBasicBlockEdge where
  sizeOf :: BNBasicBlockEdge -> Int
sizeOf BNBasicBlockEdge
_ = Int
24
  alignment :: BNBasicBlockEdge -> Int
alignment BNBasicBlockEdge
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNBasicBlockEdge -> IO BNBasicBlockEdge
peek Ptr BNBasicBlockEdge
ptr = do
    ty' <- Ptr BNBasicBlockEdge -> Int -> IO Word8
forall b. Ptr b -> Int -> IO Word8
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNBasicBlockEdge
ptr Int
0 :: IO Word8
    target' <- peekByteOff ptr 8
    backEdge' <- peekByteOff ptr 16
    fallThrough' <- peekByteOff ptr 17
    pure $ BNBasicBlockEdge (toEnum $ fromIntegral ty') target' backEdge' fallThrough'
  poke :: Ptr BNBasicBlockEdge -> BNBasicBlockEdge -> IO ()
poke Ptr BNBasicBlockEdge
ptr (BNBasicBlockEdge BNBranchType
ty' BNBasicBlockPtr
target' CBool
backEdge' CBool
fallThrough') = do
    Ptr BNBasicBlockEdge -> Int -> Int -> IO ()
forall b. Ptr b -> Int -> Int -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBasicBlockEdge
ptr Int
0 (Int -> IO ()) -> Int -> IO ()
forall a b. (a -> b) -> a -> b
$ BNBranchType -> Int
forall a. Enum a => a -> Int
fromEnum BNBranchType
ty'
    Ptr BNBasicBlockEdge -> Int -> BNBasicBlockPtr -> IO ()
forall b. Ptr b -> Int -> BNBasicBlockPtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBasicBlockEdge
ptr Int
8 BNBasicBlockPtr
target'
    Ptr BNBasicBlockEdge -> Int -> CBool -> IO ()
forall b. Ptr b -> Int -> CBool -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBasicBlockEdge
ptr Int
16 CBool
backEdge'
    Ptr BNBasicBlockEdge -> Int -> CBool -> IO ()
forall b. Ptr b -> Int -> CBool -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBasicBlockEdge
ptr Int
17 CBool
fallThrough'

data BNPossibleValueSet = BNPossibleValueSet
  { BNPossibleValueSet -> BNRegisterValueType
pvsRegisterValTy :: !BNRegisterValueType,
    BNPossibleValueSet -> Int64
psvValue :: !Int64,
    BNPossibleValueSet -> Int64
pvsOffset :: !Int64,
    BNPossibleValueSet -> CSize
pvsSize :: !CSize,
    BNPossibleValueSet -> BNValueRangePtr
pvsRanges :: !BNValueRangePtr,
    BNPossibleValueSet -> Ptr CInt
pvsValueSet :: !(Ptr CInt),
    BNPossibleValueSet -> BNLookupTableEntryPtr
pvsLookupTbl :: !BNLookupTableEntryPtr,
    BNPossibleValueSet -> CSize
pvsCount :: !CSize
  }
  deriving (Int -> BNPossibleValueSet -> ShowS
[BNPossibleValueSet] -> ShowS
BNPossibleValueSet -> String
(Int -> BNPossibleValueSet -> ShowS)
-> (BNPossibleValueSet -> String)
-> ([BNPossibleValueSet] -> ShowS)
-> Show BNPossibleValueSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNPossibleValueSet -> ShowS
showsPrec :: Int -> BNPossibleValueSet -> ShowS
$cshow :: BNPossibleValueSet -> String
show :: BNPossibleValueSet -> String
$cshowList :: [BNPossibleValueSet] -> ShowS
showList :: [BNPossibleValueSet] -> ShowS
Show, BNPossibleValueSet -> BNPossibleValueSet -> Bool
(BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> (BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> Eq BNPossibleValueSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
== :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
$c/= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
/= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
Eq, Eq BNPossibleValueSet
Eq BNPossibleValueSet =>
(BNPossibleValueSet -> BNPossibleValueSet -> Ordering)
-> (BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> (BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> (BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> (BNPossibleValueSet -> BNPossibleValueSet -> Bool)
-> (BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet)
-> (BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet)
-> Ord BNPossibleValueSet
BNPossibleValueSet -> BNPossibleValueSet -> Bool
BNPossibleValueSet -> BNPossibleValueSet -> Ordering
BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNPossibleValueSet -> BNPossibleValueSet -> Ordering
compare :: BNPossibleValueSet -> BNPossibleValueSet -> Ordering
$c< :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
< :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
$c<= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
<= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
$c> :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
> :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
$c>= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
>= :: BNPossibleValueSet -> BNPossibleValueSet -> Bool
$cmax :: BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet
max :: BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet
$cmin :: BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet
min :: BNPossibleValueSet -> BNPossibleValueSet -> BNPossibleValueSet
Ord)

instance Storable BNPossibleValueSet where
  sizeOf :: BNPossibleValueSet -> Int
sizeOf BNPossibleValueSet
_ = Int
64
  alignment :: BNPossibleValueSet -> Int
alignment BNPossibleValueSet
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNPossibleValueSet -> IO BNPossibleValueSet
peek Ptr BNPossibleValueSet
ptr = do
    rvt <- Ptr BNPossibleValueSet -> Int -> IO Word32
forall b. Ptr b -> Int -> IO Word32
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNPossibleValueSet
ptr Int
0 :: IO Word32
    val <- peekByteOff ptr 8
    offset' <- peekByteOff ptr 16
    size' <- peekByteOff ptr 24
    ranges <- peekByteOff ptr 32
    valueSet <- peekByteOff ptr 40
    lookupTbl <- peekByteOff ptr 48
    count' <- peekByteOff ptr 56
    pure (BNPossibleValueSet (toEnum $ fromIntegral rvt) val offset' size' ranges valueSet lookupTbl count')
  poke :: Ptr BNPossibleValueSet -> BNPossibleValueSet -> IO ()
poke Ptr BNPossibleValueSet
ptr (BNPossibleValueSet BNRegisterValueType
rvt Int64
val Int64
offset' CSize
size' BNValueRangePtr
ranges Ptr CInt
valueSet BNLookupTableEntryPtr
lookupTbl CSize
count') = do
    Ptr BNPossibleValueSet -> Int -> Int -> IO ()
forall b. Ptr b -> Int -> Int -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
0 (Int -> IO ()) -> Int -> IO ()
forall a b. (a -> b) -> a -> b
$ BNRegisterValueType -> Int
forall a. Enum a => a -> Int
fromEnum BNRegisterValueType
rvt
    Ptr BNPossibleValueSet -> Int -> Int64 -> IO ()
forall b. Ptr b -> Int -> Int64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
8 Int64
val
    Ptr BNPossibleValueSet -> Int -> Int64 -> IO ()
forall b. Ptr b -> Int -> Int64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
16 Int64
offset'
    Ptr BNPossibleValueSet -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
24 CSize
size'
    Ptr BNPossibleValueSet -> Int -> BNValueRangePtr -> IO ()
forall b. Ptr b -> Int -> BNValueRangePtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
32 BNValueRangePtr
ranges
    Ptr BNPossibleValueSet -> Int -> Ptr CInt -> IO ()
forall b. Ptr b -> Int -> Ptr CInt -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
40 Ptr CInt
valueSet
    Ptr BNPossibleValueSet -> Int -> BNLookupTableEntryPtr -> IO ()
forall b. Ptr b -> Int -> BNLookupTableEntryPtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
48 BNLookupTableEntryPtr
lookupTbl
    Ptr BNPossibleValueSet -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNPossibleValueSet
ptr Int
56 CSize
count'

data Function = Function
  { Function -> Int
funcAdvancedAnalysisRequests :: !Int,
    Function -> BNFunctionPtr
funcPtr :: !BNFunctionPtr,
    Function -> BNBinaryViewPtr
viewPtr :: !BNBinaryViewPtr
    -- , arch :: !BNArch
    -- , platform :: !BNPlatform
  }
  deriving (Function -> Function -> Bool
(Function -> Function -> Bool)
-> (Function -> Function -> Bool) -> Eq Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Function -> Function -> Bool
== :: Function -> Function -> Bool
$c/= :: Function -> Function -> Bool
/= :: Function -> Function -> Bool
Eq, Int -> Function -> ShowS
[Function] -> ShowS
Function -> String
(Int -> Function -> ShowS)
-> (Function -> String) -> ([Function] -> ShowS) -> Show Function
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Function -> ShowS
showsPrec :: Int -> Function -> ShowS
$cshow :: Function -> String
show :: Function -> String
$cshowList :: [Function] -> ShowS
showList :: [Function] -> ShowS
Show)

data BNStringRef = BNStringRef
  { BNStringRef -> BNStringType
bnType :: !BNStringType,
    BNStringRef -> Word64
bnStart :: !Word64,
    BNStringRef -> CSize
bnLength :: !CSize
  }
  deriving (BNStringRef -> BNStringRef -> Bool
(BNStringRef -> BNStringRef -> Bool)
-> (BNStringRef -> BNStringRef -> Bool) -> Eq BNStringRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNStringRef -> BNStringRef -> Bool
== :: BNStringRef -> BNStringRef -> Bool
$c/= :: BNStringRef -> BNStringRef -> Bool
/= :: BNStringRef -> BNStringRef -> Bool
Eq, Int -> BNStringRef -> ShowS
[BNStringRef] -> ShowS
BNStringRef -> String
(Int -> BNStringRef -> ShowS)
-> (BNStringRef -> String)
-> ([BNStringRef] -> ShowS)
-> Show BNStringRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNStringRef -> ShowS
showsPrec :: Int -> BNStringRef -> ShowS
$cshow :: BNStringRef -> String
show :: BNStringRef -> String
$cshowList :: [BNStringRef] -> ShowS
showList :: [BNStringRef] -> ShowS
Show)

instance Storable BNStringRef where
  sizeOf :: BNStringRef -> Int
sizeOf BNStringRef
_ = Int
24
  alignment :: BNStringRef -> Int
alignment BNStringRef
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNStringRef -> IO BNStringRef
peek Ptr BNStringRef
ptr = do
    t <- Ptr BNStringRef -> Int -> IO Word8
forall b. Ptr b -> Int -> IO Word8
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNStringRef
ptr Int
0 :: IO Word8
    s <- peekByteOff ptr 8 :: IO Word64
    l <- peekByteOff ptr 16 :: IO CSize
    pure (BNStringRef (toEnum $ fromIntegral t) s l)
  poke :: Ptr BNStringRef -> BNStringRef -> IO ()
poke Ptr BNStringRef
ptr (BNStringRef BNStringType
t Word64
s CSize
l) = do
    Ptr BNStringRef -> Int -> Int -> IO ()
forall b. Ptr b -> Int -> Int -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNStringRef
ptr Int
0 (Int -> IO ()) -> Int -> IO ()
forall a b. (a -> b) -> a -> b
$ BNStringType -> Int
forall a. Enum a => a -> Int
fromEnum BNStringType
t
    Ptr BNStringRef -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNStringRef
ptr Int
8 Word64
s
    Ptr BNStringRef -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNStringRef
ptr Int
16 CSize
l

data FunctionList = FunctionList
  { FunctionList -> ForeignPtr BNFunctionPtr
flArrayPtr :: !(ForeignPtr BNFunctionPtr),
    FunctionList -> Int
flCount :: !Int,
    FunctionList -> [BNFunctionPtr]
flList :: ![BNFunctionPtr],
    FunctionList -> BNBinaryViewPtr
flViewPtr :: !BNBinaryViewPtr
  }
  deriving (FunctionList -> FunctionList -> Bool
(FunctionList -> FunctionList -> Bool)
-> (FunctionList -> FunctionList -> Bool) -> Eq FunctionList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FunctionList -> FunctionList -> Bool
== :: FunctionList -> FunctionList -> Bool
$c/= :: FunctionList -> FunctionList -> Bool
/= :: FunctionList -> FunctionList -> Bool
Eq, Int -> FunctionList -> ShowS
[FunctionList] -> ShowS
FunctionList -> String
(Int -> FunctionList -> ShowS)
-> (FunctionList -> String)
-> ([FunctionList] -> ShowS)
-> Show FunctionList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FunctionList -> ShowS
showsPrec :: Int -> FunctionList -> ShowS
$cshow :: FunctionList -> String
show :: FunctionList -> String
$cshowList :: [FunctionList] -> ShowS
showList :: [FunctionList] -> ShowS
Show)

data SymbolList = SymbolList
  { SymbolList -> ForeignPtr BNSymbolPtr
slArrayPtr :: !(ForeignPtr BNSymbolPtr),
    SymbolList -> Int
slCount :: !Int,
    SymbolList -> [BNSymbolPtr]
slList :: ![BNSymbolPtr],
    SymbolList -> BNBinaryViewPtr
slViewPtr :: !BNBinaryViewPtr
  }
  deriving (SymbolList -> SymbolList -> Bool
(SymbolList -> SymbolList -> Bool)
-> (SymbolList -> SymbolList -> Bool) -> Eq SymbolList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SymbolList -> SymbolList -> Bool
== :: SymbolList -> SymbolList -> Bool
$c/= :: SymbolList -> SymbolList -> Bool
/= :: SymbolList -> SymbolList -> Bool
Eq, Int -> SymbolList -> ShowS
[SymbolList] -> ShowS
SymbolList -> String
(Int -> SymbolList -> ShowS)
-> (SymbolList -> String)
-> ([SymbolList] -> ShowS)
-> Show SymbolList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SymbolList -> ShowS
showsPrec :: Int -> SymbolList -> ShowS
$cshow :: SymbolList -> String
show :: SymbolList -> String
$cshowList :: [SymbolList] -> ShowS
showList :: [SymbolList] -> ShowS
Show)

data SymbolType
  = FunctionSymbol
  | ImportAddressSymbol
  | ImportedFunctionSymbol
  | DataSymbol
  | ImportedDataSymbol
  | ExternalSymbol
  | LibraryFunctionSymbol
  | SymbolicFunctionSymbol
  | LocalLabelSymbol
  deriving (SymbolType -> SymbolType -> Bool
(SymbolType -> SymbolType -> Bool)
-> (SymbolType -> SymbolType -> Bool) -> Eq SymbolType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SymbolType -> SymbolType -> Bool
== :: SymbolType -> SymbolType -> Bool
$c/= :: SymbolType -> SymbolType -> Bool
/= :: SymbolType -> SymbolType -> Bool
Eq, Int -> SymbolType -> ShowS
[SymbolType] -> ShowS
SymbolType -> String
(Int -> SymbolType -> ShowS)
-> (SymbolType -> String)
-> ([SymbolType] -> ShowS)
-> Show SymbolType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SymbolType -> ShowS
showsPrec :: Int -> SymbolType -> ShowS
$cshow :: SymbolType -> String
show :: SymbolType -> String
$cshowList :: [SymbolType] -> ShowS
showList :: [SymbolType] -> ShowS
Show, Int -> SymbolType
SymbolType -> Int
SymbolType -> [SymbolType]
SymbolType -> SymbolType
SymbolType -> SymbolType -> [SymbolType]
SymbolType -> SymbolType -> SymbolType -> [SymbolType]
(SymbolType -> SymbolType)
-> (SymbolType -> SymbolType)
-> (Int -> SymbolType)
-> (SymbolType -> Int)
-> (SymbolType -> [SymbolType])
-> (SymbolType -> SymbolType -> [SymbolType])
-> (SymbolType -> SymbolType -> [SymbolType])
-> (SymbolType -> SymbolType -> SymbolType -> [SymbolType])
-> Enum SymbolType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SymbolType -> SymbolType
succ :: SymbolType -> SymbolType
$cpred :: SymbolType -> SymbolType
pred :: SymbolType -> SymbolType
$ctoEnum :: Int -> SymbolType
toEnum :: Int -> SymbolType
$cfromEnum :: SymbolType -> Int
fromEnum :: SymbolType -> Int
$cenumFrom :: SymbolType -> [SymbolType]
enumFrom :: SymbolType -> [SymbolType]
$cenumFromThen :: SymbolType -> SymbolType -> [SymbolType]
enumFromThen :: SymbolType -> SymbolType -> [SymbolType]
$cenumFromTo :: SymbolType -> SymbolType -> [SymbolType]
enumFromTo :: SymbolType -> SymbolType -> [SymbolType]
$cenumFromThenTo :: SymbolType -> SymbolType -> SymbolType -> [SymbolType]
enumFromThenTo :: SymbolType -> SymbolType -> SymbolType -> [SymbolType]
Enum, Eq SymbolType
Eq SymbolType =>
(SymbolType -> SymbolType -> Ordering)
-> (SymbolType -> SymbolType -> Bool)
-> (SymbolType -> SymbolType -> Bool)
-> (SymbolType -> SymbolType -> Bool)
-> (SymbolType -> SymbolType -> Bool)
-> (SymbolType -> SymbolType -> SymbolType)
-> (SymbolType -> SymbolType -> SymbolType)
-> Ord SymbolType
SymbolType -> SymbolType -> Bool
SymbolType -> SymbolType -> Ordering
SymbolType -> SymbolType -> SymbolType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SymbolType -> SymbolType -> Ordering
compare :: SymbolType -> SymbolType -> Ordering
$c< :: SymbolType -> SymbolType -> Bool
< :: SymbolType -> SymbolType -> Bool
$c<= :: SymbolType -> SymbolType -> Bool
<= :: SymbolType -> SymbolType -> Bool
$c> :: SymbolType -> SymbolType -> Bool
> :: SymbolType -> SymbolType -> Bool
$c>= :: SymbolType -> SymbolType -> Bool
>= :: SymbolType -> SymbolType -> Bool
$cmax :: SymbolType -> SymbolType -> SymbolType
max :: SymbolType -> SymbolType -> SymbolType
$cmin :: SymbolType -> SymbolType -> SymbolType
min :: SymbolType -> SymbolType -> SymbolType
Ord)

data SymbolBinding = NoBinding | LocalBinding | GlobalBinding | WeakBinding
  deriving (SymbolBinding -> SymbolBinding -> Bool
(SymbolBinding -> SymbolBinding -> Bool)
-> (SymbolBinding -> SymbolBinding -> Bool) -> Eq SymbolBinding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SymbolBinding -> SymbolBinding -> Bool
== :: SymbolBinding -> SymbolBinding -> Bool
$c/= :: SymbolBinding -> SymbolBinding -> Bool
/= :: SymbolBinding -> SymbolBinding -> Bool
Eq, Int -> SymbolBinding -> ShowS
[SymbolBinding] -> ShowS
SymbolBinding -> String
(Int -> SymbolBinding -> ShowS)
-> (SymbolBinding -> String)
-> ([SymbolBinding] -> ShowS)
-> Show SymbolBinding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SymbolBinding -> ShowS
showsPrec :: Int -> SymbolBinding -> ShowS
$cshow :: SymbolBinding -> String
show :: SymbolBinding -> String
$cshowList :: [SymbolBinding] -> ShowS
showList :: [SymbolBinding] -> ShowS
Show, Int -> SymbolBinding
SymbolBinding -> Int
SymbolBinding -> [SymbolBinding]
SymbolBinding -> SymbolBinding
SymbolBinding -> SymbolBinding -> [SymbolBinding]
SymbolBinding -> SymbolBinding -> SymbolBinding -> [SymbolBinding]
(SymbolBinding -> SymbolBinding)
-> (SymbolBinding -> SymbolBinding)
-> (Int -> SymbolBinding)
-> (SymbolBinding -> Int)
-> (SymbolBinding -> [SymbolBinding])
-> (SymbolBinding -> SymbolBinding -> [SymbolBinding])
-> (SymbolBinding -> SymbolBinding -> [SymbolBinding])
-> (SymbolBinding
    -> SymbolBinding -> SymbolBinding -> [SymbolBinding])
-> Enum SymbolBinding
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SymbolBinding -> SymbolBinding
succ :: SymbolBinding -> SymbolBinding
$cpred :: SymbolBinding -> SymbolBinding
pred :: SymbolBinding -> SymbolBinding
$ctoEnum :: Int -> SymbolBinding
toEnum :: Int -> SymbolBinding
$cfromEnum :: SymbolBinding -> Int
fromEnum :: SymbolBinding -> Int
$cenumFrom :: SymbolBinding -> [SymbolBinding]
enumFrom :: SymbolBinding -> [SymbolBinding]
$cenumFromThen :: SymbolBinding -> SymbolBinding -> [SymbolBinding]
enumFromThen :: SymbolBinding -> SymbolBinding -> [SymbolBinding]
$cenumFromTo :: SymbolBinding -> SymbolBinding -> [SymbolBinding]
enumFromTo :: SymbolBinding -> SymbolBinding -> [SymbolBinding]
$cenumFromThenTo :: SymbolBinding -> SymbolBinding -> SymbolBinding -> [SymbolBinding]
enumFromThenTo :: SymbolBinding -> SymbolBinding -> SymbolBinding -> [SymbolBinding]
Enum, Eq SymbolBinding
Eq SymbolBinding =>
(SymbolBinding -> SymbolBinding -> Ordering)
-> (SymbolBinding -> SymbolBinding -> Bool)
-> (SymbolBinding -> SymbolBinding -> Bool)
-> (SymbolBinding -> SymbolBinding -> Bool)
-> (SymbolBinding -> SymbolBinding -> Bool)
-> (SymbolBinding -> SymbolBinding -> SymbolBinding)
-> (SymbolBinding -> SymbolBinding -> SymbolBinding)
-> Ord SymbolBinding
SymbolBinding -> SymbolBinding -> Bool
SymbolBinding -> SymbolBinding -> Ordering
SymbolBinding -> SymbolBinding -> SymbolBinding
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SymbolBinding -> SymbolBinding -> Ordering
compare :: SymbolBinding -> SymbolBinding -> Ordering
$c< :: SymbolBinding -> SymbolBinding -> Bool
< :: SymbolBinding -> SymbolBinding -> Bool
$c<= :: SymbolBinding -> SymbolBinding -> Bool
<= :: SymbolBinding -> SymbolBinding -> Bool
$c> :: SymbolBinding -> SymbolBinding -> Bool
> :: SymbolBinding -> SymbolBinding -> Bool
$c>= :: SymbolBinding -> SymbolBinding -> Bool
>= :: SymbolBinding -> SymbolBinding -> Bool
$cmax :: SymbolBinding -> SymbolBinding -> SymbolBinding
max :: SymbolBinding -> SymbolBinding -> SymbolBinding
$cmin :: SymbolBinding -> SymbolBinding -> SymbolBinding
min :: SymbolBinding -> SymbolBinding -> SymbolBinding
Ord)

data Symbol = Symbol
  { Symbol -> String
name :: String,
    Symbol -> SymbolType
ty :: SymbolType,
    Symbol -> SymbolBinding
binding :: SymbolBinding,
    Symbol -> Word64
address :: Word64,
    Symbol -> Bool
auto :: Bool
  }
  deriving (Symbol -> Symbol -> Bool
(Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool) -> Eq Symbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Symbol -> Symbol -> Bool
== :: Symbol -> Symbol -> Bool
$c/= :: Symbol -> Symbol -> Bool
/= :: Symbol -> Symbol -> Bool
Eq, Eq Symbol
Eq Symbol =>
(Symbol -> Symbol -> Ordering)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Symbol)
-> (Symbol -> Symbol -> Symbol)
-> Ord Symbol
Symbol -> Symbol -> Bool
Symbol -> Symbol -> Ordering
Symbol -> Symbol -> Symbol
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Symbol -> Symbol -> Ordering
compare :: Symbol -> Symbol -> Ordering
$c< :: Symbol -> Symbol -> Bool
< :: Symbol -> Symbol -> Bool
$c<= :: Symbol -> Symbol -> Bool
<= :: Symbol -> Symbol -> Bool
$c> :: Symbol -> Symbol -> Bool
> :: Symbol -> Symbol -> Bool
$c>= :: Symbol -> Symbol -> Bool
>= :: Symbol -> Symbol -> Bool
$cmax :: Symbol -> Symbol -> Symbol
max :: Symbol -> Symbol -> Symbol
$cmin :: Symbol -> Symbol -> Symbol
min :: Symbol -> Symbol -> Symbol
Ord)

instance Show Symbol where
  show :: Symbol -> String
show (Symbol String
name' SymbolType
ty' SymbolBinding
binding' Word64
address' Bool
auto') =
    String
"Symbol {name = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
name'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", ty = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ SymbolType -> String
forall a. Show a => a -> String
show SymbolType
ty'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", binding = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ SymbolBinding -> String
forall a. Show a => a -> String
show SymbolBinding
binding'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", address = 0x"
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word64 -> ShowS
forall a. Integral a => a -> ShowS
showHex Word64
address' String
""
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", auto = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ Bool -> String
forall a. Show a => a -> String
show Bool
auto'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"}"

data BNStringType = AsciiString | Utf16String | Utf32String | Utf8String
  deriving (BNStringType -> BNStringType -> Bool
(BNStringType -> BNStringType -> Bool)
-> (BNStringType -> BNStringType -> Bool) -> Eq BNStringType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNStringType -> BNStringType -> Bool
== :: BNStringType -> BNStringType -> Bool
$c/= :: BNStringType -> BNStringType -> Bool
/= :: BNStringType -> BNStringType -> Bool
Eq, Int -> BNStringType -> ShowS
[BNStringType] -> ShowS
BNStringType -> String
(Int -> BNStringType -> ShowS)
-> (BNStringType -> String)
-> ([BNStringType] -> ShowS)
-> Show BNStringType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNStringType -> ShowS
showsPrec :: Int -> BNStringType -> ShowS
$cshow :: BNStringType -> String
show :: BNStringType -> String
$cshowList :: [BNStringType] -> ShowS
showList :: [BNStringType] -> ShowS
Show, Int -> BNStringType
BNStringType -> Int
BNStringType -> [BNStringType]
BNStringType -> BNStringType
BNStringType -> BNStringType -> [BNStringType]
BNStringType -> BNStringType -> BNStringType -> [BNStringType]
(BNStringType -> BNStringType)
-> (BNStringType -> BNStringType)
-> (Int -> BNStringType)
-> (BNStringType -> Int)
-> (BNStringType -> [BNStringType])
-> (BNStringType -> BNStringType -> [BNStringType])
-> (BNStringType -> BNStringType -> [BNStringType])
-> (BNStringType -> BNStringType -> BNStringType -> [BNStringType])
-> Enum BNStringType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNStringType -> BNStringType
succ :: BNStringType -> BNStringType
$cpred :: BNStringType -> BNStringType
pred :: BNStringType -> BNStringType
$ctoEnum :: Int -> BNStringType
toEnum :: Int -> BNStringType
$cfromEnum :: BNStringType -> Int
fromEnum :: BNStringType -> Int
$cenumFrom :: BNStringType -> [BNStringType]
enumFrom :: BNStringType -> [BNStringType]
$cenumFromThen :: BNStringType -> BNStringType -> [BNStringType]
enumFromThen :: BNStringType -> BNStringType -> [BNStringType]
$cenumFromTo :: BNStringType -> BNStringType -> [BNStringType]
enumFromTo :: BNStringType -> BNStringType -> [BNStringType]
$cenumFromThenTo :: BNStringType -> BNStringType -> BNStringType -> [BNStringType]
enumFromThenTo :: BNStringType -> BNStringType -> BNStringType -> [BNStringType]
Enum)

data BNLowLevelILInstruction = BNLowLevelILInstruction
  { BNLowLevelILInstruction -> Word8
llOperation :: !Word8,
    BNLowLevelILInstruction -> Word32
llAttributes :: !Word32,
    BNLowLevelILInstruction -> CSize
llSize :: !CSize,
    BNLowLevelILInstruction -> CUInt
llFlags :: !CUInt,
    BNLowLevelILInstruction -> CUInt
llSourceOperand :: !CUInt,
    BNLowLevelILInstruction -> CULLong
llOp0 :: !CULLong,
    BNLowLevelILInstruction -> CULLong
llOp1 :: !CULLong,
    BNLowLevelILInstruction -> CULLong
llOp2 :: !CULLong,
    BNLowLevelILInstruction -> CULLong
llOp3 :: !CULLong,
    BNLowLevelILInstruction -> CULLong
llAddress :: !CULLong
  }
  deriving (BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool
(BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool)
-> (BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool)
-> Eq BNLowLevelILInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool
== :: BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool
$c/= :: BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool
/= :: BNLowLevelILInstruction -> BNLowLevelILInstruction -> Bool
Eq, Int -> BNLowLevelILInstruction -> ShowS
[BNLowLevelILInstruction] -> ShowS
BNLowLevelILInstruction -> String
(Int -> BNLowLevelILInstruction -> ShowS)
-> (BNLowLevelILInstruction -> String)
-> ([BNLowLevelILInstruction] -> ShowS)
-> Show BNLowLevelILInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNLowLevelILInstruction -> ShowS
showsPrec :: Int -> BNLowLevelILInstruction -> ShowS
$cshow :: BNLowLevelILInstruction -> String
show :: BNLowLevelILInstruction -> String
$cshowList :: [BNLowLevelILInstruction] -> ShowS
showList :: [BNLowLevelILInstruction] -> ShowS
Show)

instance Storable BNLowLevelILInstruction where
  sizeOf :: BNLowLevelILInstruction -> Int
sizeOf BNLowLevelILInstruction
_ = Int
64
  alignment :: BNLowLevelILInstruction -> Int
alignment BNLowLevelILInstruction
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNLowLevelILInstruction -> IO BNLowLevelILInstruction
peek Ptr BNLowLevelILInstruction
ptr = do
    op <- Ptr BNLowLevelILInstruction -> Int -> IO Word8
forall b. Ptr b -> Int -> IO Word8
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNLowLevelILInstruction
ptr Int
0 :: IO Word8
    attr <- peekByteOff ptr 4
    sz <- peekByteOff ptr 8
    flg <- peekByteOff ptr 16
    srcOp <- peekByteOff ptr 20
    o0 <- peekByteOff ptr 24
    o1 <- peekByteOff ptr 32
    o2 <- peekByteOff ptr 40
    o3 <- peekByteOff ptr 48
    addr <- peekByteOff ptr 56
    pure (BNLowLevelILInstruction op attr sz flg srcOp o0 o1 o2 o3 addr)
  poke :: Ptr BNLowLevelILInstruction -> BNLowLevelILInstruction -> IO ()
poke Ptr BNLowLevelILInstruction
ptr (BNLowLevelILInstruction Word8
op Word32
attr CSize
sz CUInt
flg CUInt
srcOp CULLong
o0 CULLong
o1 CULLong
o2 CULLong
o3 CULLong
addr) = do
    Ptr BNLowLevelILInstruction -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
0 Word8
op
    Ptr BNLowLevelILInstruction -> Int -> Word32 -> IO ()
forall b. Ptr b -> Int -> Word32 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
4 Word32
attr
    Ptr BNLowLevelILInstruction -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
8 CSize
sz
    Ptr BNLowLevelILInstruction -> Int -> CUInt -> IO ()
forall b. Ptr b -> Int -> CUInt -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
16 CUInt
flg
    Ptr BNLowLevelILInstruction -> Int -> CUInt -> IO ()
forall b. Ptr b -> Int -> CUInt -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
20 CUInt
srcOp
    Ptr BNLowLevelILInstruction -> Int -> CULLong -> IO ()
forall b. Ptr b -> Int -> CULLong -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
24 CULLong
o0
    Ptr BNLowLevelILInstruction -> Int -> CULLong -> IO ()
forall b. Ptr b -> Int -> CULLong -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
32 CULLong
o1
    Ptr BNLowLevelILInstruction -> Int -> CULLong -> IO ()
forall b. Ptr b -> Int -> CULLong -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
40 CULLong
o2
    Ptr BNLowLevelILInstruction -> Int -> CULLong -> IO ()
forall b. Ptr b -> Int -> CULLong -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
48 CULLong
o3
    Ptr BNLowLevelILInstruction -> Int -> CULLong -> IO ()
forall b. Ptr b -> Int -> CULLong -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNLowLevelILInstruction
ptr Int
56 CULLong
addr

data BNLowLevelILOperation
  = LLIL_NOP
  | LLIL_SET_REG
  | LLIL_SET_REG_SPLIT
  | LLIL_SET_FLAG
  | LLIL_SET_REG_STACK_REL
  | LLIL_REG_STACK_PUSH
  | LLIL_ASSERT
  | LLIL_FORCE_VER
  | LLIL_LOAD
  | LLIL_STORE
  | LLIL_PUSH
  | LLIL_POP
  | LLIL_REG
  | LLIL_REG_SPLIT
  | LLIL_REG_STACK_REL
  | LLIL_REG_STACK_POP
  | LLIL_REG_STACK_FREE_REG
  | LLIL_REG_STACK_FREE_REL
  | LLIL_CONST
  | LLIL_CONST_PTR
  | LLIL_EXTERN_PTR
  | LLIL_FLOAT_CONST
  | LLIL_FLAG
  | LLIL_FLAG_BIT
  | LLIL_ADD
  | LLIL_ADC
  | LLIL_SUB
  | LLIL_SBB
  | LLIL_AND
  | LLIL_OR
  | LLIL_XOR
  | LLIL_LSL
  | LLIL_LSR
  | LLIL_ASR
  | LLIL_ROL
  | LLIL_RLC
  | LLIL_ROR
  | LLIL_RRC
  | LLIL_MUL
  | LLIL_MULU_DP
  | LLIL_MULS_DP
  | LLIL_DIVU
  | LLIL_DIVU_DP
  | LLIL_DIVS
  | LLIL_DIVS_DP
  | LLIL_MODU
  | LLIL_MODU_DP
  | LLIL_MODS
  | LLIL_MODS_DP
  | LLIL_NEG
  | LLIL_NOT
  | LLIL_SX
  | LLIL_ZX
  | LLIL_LOW_PART
  | LLIL_JUMP
  | LLIL_JUMP_TO
  | LLIL_CALL
  | LLIL_CALL_STACK_ADJUST
  | LLIL_TAILCALL
  | LLIL_RET
  | LLIL_NORET
  | LLIL_IF
  | LLIL_GOTO
  | LLIL_FLAG_COND
  | LLIL_FLAG_GROUP
  | LLIL_CMP_E
  | LLIL_CMP_NE
  | LLIL_CMP_SLT
  | LLIL_CMP_ULT
  | LLIL_CMP_SLE
  | LLIL_CMP_ULE
  | LLIL_CMP_SGE
  | LLIL_CMP_UGE
  | LLIL_CMP_SGT
  | LLIL_CMP_UGT
  | LLIL_TEST_BIT
  | LLIL_BOOL_TO_INT
  | LLIL_ADD_OVERFLOW
  | LLIL_SYSCALL
  | LLIL_BP
  | LLIL_TRAP
  | LLIL_INTRINSIC
  | LLIL_UNDEF
  | LLIL_UNIMPL
  | LLIL_UNIMPL_MEM
  | LLIL_FADD
  | LLIL_FSUB
  | LLIL_FMUL
  | LLIL_FDIV
  | LLIL_FSQRT
  | LLIL_FNEG
  | LLIL_FABS
  | LLIL_FLOAT_TO_INT
  | LLIL_INT_TO_FLOAT
  | LLIL_FLOAT_CONV
  | LLIL_ROUND_TO_INT
  | LLIL_FLOOR
  | LLIL_CEIL
  | LLIL_FTRUNC
  | LLIL_FCMP_E
  | LLIL_FCMP_NE
  | LLIL_FCMP_LT
  | LLIL_FCMP_LE
  | LLIL_FCMP_GE
  | LLIL_FCMP_GT
  | LLIL_FCMP_O
  | LLIL_FCMP_UO
  | LLIL_SET_REG_SSA
  | LLIL_SET_REG_SSA_PARTIAL
  | LLIL_SET_REG_SPLIT_SSA
  | LLIL_SET_REG_STACK_REL_SSA
  | LLIL_SET_REG_STACK_ABS_SSA
  | LLIL_REG_SPLIT_DEST_SSA
  | LLIL_REG_STACK_DEST_SSA
  | LLIL_REG_SSA
  | LLIL_REG_SSA_PARTIAL
  | LLIL_REG_SPLIT_SSA
  | LLIL_REG_STACK_REL_SSA
  | LLIL_REG_STACK_ABS_SSA
  | LLIL_REG_STACK_FREE_REL_SSA
  | LLIL_REG_STACK_FREE_ABS_SSA
  | LLIL_SET_FLAG_SSA
  | LLIL_ASSERT_SSA
  | LLIL_FORCE_VER_SSA
  | LLIL_FLAG_SSA
  | LLIL_FLAG_BIT_SSA
  | LLIL_CALL_SSA
  | LLIL_SYSCALL_SSA
  | LLIL_TAILCALL_SSA
  | LLIL_CALL_PARAM
  | LLIL_CALL_STACK_SSA
  | LLIL_CALL_OUTPUT_SSA
  | LLIL_SEPARATE_PARAM_LIST_SSA
  | LLIL_SHARED_PARAM_SLOT_SSA
  | LLIL_MEMORY_INTRINSIC_OUTPUT_SSA
  | LLIL_LOAD_SSA
  | LLIL_STORE_SSA
  | LLIL_INTRINSIC_SSA
  | LLIL_MEMORY_INTRINSIC_SSA
  | LLIL_REG_PHI
  | LLIL_REG_STACK_PHI
  | LLIL_FLAG_PHI
  | LLIL_MEM_PHI
  | LLIL_BSWAP
  | LLIL_POPCNT
  | LLIL_CLZ
  | LLIL_CTZ
  | LLIL_RBIT
  | LLIL_CLS
  | LLIL_MINS
  | LLIL_MAXS
  | LLIL_MINU
  | LLIL_MAXU
  | LLIL_ABS
  deriving (BNLowLevelILOperation -> BNLowLevelILOperation -> Bool
(BNLowLevelILOperation -> BNLowLevelILOperation -> Bool)
-> (BNLowLevelILOperation -> BNLowLevelILOperation -> Bool)
-> Eq BNLowLevelILOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNLowLevelILOperation -> BNLowLevelILOperation -> Bool
== :: BNLowLevelILOperation -> BNLowLevelILOperation -> Bool
$c/= :: BNLowLevelILOperation -> BNLowLevelILOperation -> Bool
/= :: BNLowLevelILOperation -> BNLowLevelILOperation -> Bool
Eq, Int -> BNLowLevelILOperation -> ShowS
[BNLowLevelILOperation] -> ShowS
BNLowLevelILOperation -> String
(Int -> BNLowLevelILOperation -> ShowS)
-> (BNLowLevelILOperation -> String)
-> ([BNLowLevelILOperation] -> ShowS)
-> Show BNLowLevelILOperation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNLowLevelILOperation -> ShowS
showsPrec :: Int -> BNLowLevelILOperation -> ShowS
$cshow :: BNLowLevelILOperation -> String
show :: BNLowLevelILOperation -> String
$cshowList :: [BNLowLevelILOperation] -> ShowS
showList :: [BNLowLevelILOperation] -> ShowS
Show, Int -> BNLowLevelILOperation
BNLowLevelILOperation -> Int
BNLowLevelILOperation -> [BNLowLevelILOperation]
BNLowLevelILOperation -> BNLowLevelILOperation
BNLowLevelILOperation
-> BNLowLevelILOperation -> [BNLowLevelILOperation]
BNLowLevelILOperation
-> BNLowLevelILOperation
-> BNLowLevelILOperation
-> [BNLowLevelILOperation]
(BNLowLevelILOperation -> BNLowLevelILOperation)
-> (BNLowLevelILOperation -> BNLowLevelILOperation)
-> (Int -> BNLowLevelILOperation)
-> (BNLowLevelILOperation -> Int)
-> (BNLowLevelILOperation -> [BNLowLevelILOperation])
-> (BNLowLevelILOperation
    -> BNLowLevelILOperation -> [BNLowLevelILOperation])
-> (BNLowLevelILOperation
    -> BNLowLevelILOperation -> [BNLowLevelILOperation])
-> (BNLowLevelILOperation
    -> BNLowLevelILOperation
    -> BNLowLevelILOperation
    -> [BNLowLevelILOperation])
-> Enum BNLowLevelILOperation
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNLowLevelILOperation -> BNLowLevelILOperation
succ :: BNLowLevelILOperation -> BNLowLevelILOperation
$cpred :: BNLowLevelILOperation -> BNLowLevelILOperation
pred :: BNLowLevelILOperation -> BNLowLevelILOperation
$ctoEnum :: Int -> BNLowLevelILOperation
toEnum :: Int -> BNLowLevelILOperation
$cfromEnum :: BNLowLevelILOperation -> Int
fromEnum :: BNLowLevelILOperation -> Int
$cenumFrom :: BNLowLevelILOperation -> [BNLowLevelILOperation]
enumFrom :: BNLowLevelILOperation -> [BNLowLevelILOperation]
$cenumFromThen :: BNLowLevelILOperation
-> BNLowLevelILOperation -> [BNLowLevelILOperation]
enumFromThen :: BNLowLevelILOperation
-> BNLowLevelILOperation -> [BNLowLevelILOperation]
$cenumFromTo :: BNLowLevelILOperation
-> BNLowLevelILOperation -> [BNLowLevelILOperation]
enumFromTo :: BNLowLevelILOperation
-> BNLowLevelILOperation -> [BNLowLevelILOperation]
$cenumFromThenTo :: BNLowLevelILOperation
-> BNLowLevelILOperation
-> BNLowLevelILOperation
-> [BNLowLevelILOperation]
enumFromThenTo :: BNLowLevelILOperation
-> BNLowLevelILOperation
-> BNLowLevelILOperation
-> [BNLowLevelILOperation]
Enum)

data BNRegisterValueType
  = UndeterminedValue
  | EntryValue
  | ConstantValue
  | ConstantPointerValue
  | ExternalPointerValue
  | StackFrameOffset
  | ReturnAddressValue
  | ImportedAddressValue
  | SignedRangeValue
  | UnsignedRangeValue
  | LookupTableValue
  | InSetOfValues
  | NotInSetOfValues
  | ConstantDataValue
  | ConstantDataZeroExtendValue
  | ConstantDataSignExtendValue
  | ConstantDataAggregateValue
  deriving (BNRegisterValueType -> BNRegisterValueType -> Bool
(BNRegisterValueType -> BNRegisterValueType -> Bool)
-> (BNRegisterValueType -> BNRegisterValueType -> Bool)
-> Eq BNRegisterValueType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNRegisterValueType -> BNRegisterValueType -> Bool
== :: BNRegisterValueType -> BNRegisterValueType -> Bool
$c/= :: BNRegisterValueType -> BNRegisterValueType -> Bool
/= :: BNRegisterValueType -> BNRegisterValueType -> Bool
Eq, Eq BNRegisterValueType
Eq BNRegisterValueType =>
(BNRegisterValueType -> BNRegisterValueType -> Ordering)
-> (BNRegisterValueType -> BNRegisterValueType -> Bool)
-> (BNRegisterValueType -> BNRegisterValueType -> Bool)
-> (BNRegisterValueType -> BNRegisterValueType -> Bool)
-> (BNRegisterValueType -> BNRegisterValueType -> Bool)
-> (BNRegisterValueType
    -> BNRegisterValueType -> BNRegisterValueType)
-> (BNRegisterValueType
    -> BNRegisterValueType -> BNRegisterValueType)
-> Ord BNRegisterValueType
BNRegisterValueType -> BNRegisterValueType -> Bool
BNRegisterValueType -> BNRegisterValueType -> Ordering
BNRegisterValueType -> BNRegisterValueType -> BNRegisterValueType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNRegisterValueType -> BNRegisterValueType -> Ordering
compare :: BNRegisterValueType -> BNRegisterValueType -> Ordering
$c< :: BNRegisterValueType -> BNRegisterValueType -> Bool
< :: BNRegisterValueType -> BNRegisterValueType -> Bool
$c<= :: BNRegisterValueType -> BNRegisterValueType -> Bool
<= :: BNRegisterValueType -> BNRegisterValueType -> Bool
$c> :: BNRegisterValueType -> BNRegisterValueType -> Bool
> :: BNRegisterValueType -> BNRegisterValueType -> Bool
$c>= :: BNRegisterValueType -> BNRegisterValueType -> Bool
>= :: BNRegisterValueType -> BNRegisterValueType -> Bool
$cmax :: BNRegisterValueType -> BNRegisterValueType -> BNRegisterValueType
max :: BNRegisterValueType -> BNRegisterValueType -> BNRegisterValueType
$cmin :: BNRegisterValueType -> BNRegisterValueType -> BNRegisterValueType
min :: BNRegisterValueType -> BNRegisterValueType -> BNRegisterValueType
Ord, Int -> BNRegisterValueType -> ShowS
[BNRegisterValueType] -> ShowS
BNRegisterValueType -> String
(Int -> BNRegisterValueType -> ShowS)
-> (BNRegisterValueType -> String)
-> ([BNRegisterValueType] -> ShowS)
-> Show BNRegisterValueType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNRegisterValueType -> ShowS
showsPrec :: Int -> BNRegisterValueType -> ShowS
$cshow :: BNRegisterValueType -> String
show :: BNRegisterValueType -> String
$cshowList :: [BNRegisterValueType] -> ShowS
showList :: [BNRegisterValueType] -> ShowS
Show)

instance Enum BNRegisterValueType where
  fromEnum :: BNRegisterValueType -> Int
fromEnum BNRegisterValueType
UndeterminedValue = Int
0
  fromEnum BNRegisterValueType
EntryValue = Int
1
  fromEnum BNRegisterValueType
ConstantValue = Int
2
  fromEnum BNRegisterValueType
ConstantPointerValue = Int
3
  fromEnum BNRegisterValueType
ExternalPointerValue = Int
4
  fromEnum BNRegisterValueType
StackFrameOffset = Int
5
  fromEnum BNRegisterValueType
ReturnAddressValue = Int
6
  fromEnum BNRegisterValueType
ImportedAddressValue = Int
7
  fromEnum BNRegisterValueType
SignedRangeValue = Int
8
  fromEnum BNRegisterValueType
UnsignedRangeValue = Int
9
  fromEnum BNRegisterValueType
LookupTableValue = Int
10
  fromEnum BNRegisterValueType
InSetOfValues = Int
11
  fromEnum BNRegisterValueType
NotInSetOfValues = Int
12
  fromEnum BNRegisterValueType
ConstantDataValue = Int
0x8000
  fromEnum BNRegisterValueType
ConstantDataZeroExtendValue = Int
0x8001
  fromEnum BNRegisterValueType
ConstantDataSignExtendValue = Int
0x8002
  fromEnum BNRegisterValueType
ConstantDataAggregateValue = Int
0x8003

  toEnum :: Int -> BNRegisterValueType
toEnum Int
0x0000 = BNRegisterValueType
UndeterminedValue
  toEnum Int
0x0001 = BNRegisterValueType
EntryValue
  toEnum Int
0x0002 = BNRegisterValueType
ConstantValue
  toEnum Int
0x0003 = BNRegisterValueType
ConstantPointerValue
  toEnum Int
0x0004 = BNRegisterValueType
ExternalPointerValue
  toEnum Int
0x0005 = BNRegisterValueType
StackFrameOffset
  toEnum Int
0x0006 = BNRegisterValueType
ReturnAddressValue
  toEnum Int
0x0007 = BNRegisterValueType
ImportedAddressValue
  toEnum Int
0x0008 = BNRegisterValueType
SignedRangeValue
  toEnum Int
0x0009 = BNRegisterValueType
UnsignedRangeValue
  toEnum Int
0x000A = BNRegisterValueType
LookupTableValue
  toEnum Int
0x000B = BNRegisterValueType
InSetOfValues
  toEnum Int
0x000C = BNRegisterValueType
NotInSetOfValues
  toEnum Int
0x8000 = BNRegisterValueType
ConstantDataValue
  toEnum Int
0x8001 = BNRegisterValueType
ConstantDataZeroExtendValue
  toEnum Int
0x8002 = BNRegisterValueType
ConstantDataSignExtendValue
  toEnum Int
0x8003 = BNRegisterValueType
ConstantDataAggregateValue
  toEnum Int
n = String -> BNRegisterValueType
forall a. HasCallStack => String -> a
error (String -> BNRegisterValueType) -> String -> BNRegisterValueType
forall a b. (a -> b) -> a -> b
$ String
"BNRegisterValueType.toEnum: invalid tag " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n

instance Storable BNReferenceSource where
  sizeOf :: BNReferenceSource -> Int
sizeOf BNReferenceSource
_ = Int
24
  alignment :: BNReferenceSource -> Int
alignment BNReferenceSource
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNReferenceSource -> IO BNReferenceSource
peek Ptr BNReferenceSource
ptr = do
    f <- Ptr BNReferenceSource -> Int -> IO BNFunctionPtr
forall b. Ptr b -> Int -> IO BNFunctionPtr
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNReferenceSource
ptr Int
0 :: IO BNFunctionPtr
    a <- peekByteOff ptr 8 :: IO BNArchPtr
    addr <- peekByteOff ptr 16 :: IO Word64
    pure $ BNReferenceSource f a addr
  poke :: Ptr BNReferenceSource -> BNReferenceSource -> IO ()
poke Ptr BNReferenceSource
ptr (BNReferenceSource BNFunctionPtr
f BNArchPtr
a Word64
addr) = do
    Ptr BNReferenceSource -> Int -> BNFunctionPtr -> IO ()
forall b. Ptr b -> Int -> BNFunctionPtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNReferenceSource
ptr Int
0 BNFunctionPtr
f
    Ptr BNReferenceSource -> Int -> BNArchPtr -> IO ()
forall b. Ptr b -> Int -> BNArchPtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNReferenceSource
ptr Int
8 BNArchPtr
a
    Ptr BNReferenceSource -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNReferenceSource
ptr Int
16 Word64
addr

data BNReferenceSource = BNReferenceSource
  { BNReferenceSource -> BNFunctionPtr
bnFunc :: !BNFunctionPtr,
    BNReferenceSource -> BNArchPtr
bnArch :: !BNArchPtr,
    BNReferenceSource -> Word64
bnAddr :: !Word64
  }
  deriving (Int -> BNReferenceSource -> ShowS
[BNReferenceSource] -> ShowS
BNReferenceSource -> String
(Int -> BNReferenceSource -> ShowS)
-> (BNReferenceSource -> String)
-> ([BNReferenceSource] -> ShowS)
-> Show BNReferenceSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNReferenceSource -> ShowS
showsPrec :: Int -> BNReferenceSource -> ShowS
$cshow :: BNReferenceSource -> String
show :: BNReferenceSource -> String
$cshowList :: [BNReferenceSource] -> ShowS
showList :: [BNReferenceSource] -> ShowS
Show, BNReferenceSource -> BNReferenceSource -> Bool
(BNReferenceSource -> BNReferenceSource -> Bool)
-> (BNReferenceSource -> BNReferenceSource -> Bool)
-> Eq BNReferenceSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNReferenceSource -> BNReferenceSource -> Bool
== :: BNReferenceSource -> BNReferenceSource -> Bool
$c/= :: BNReferenceSource -> BNReferenceSource -> Bool
/= :: BNReferenceSource -> BNReferenceSource -> Bool
Eq)

data BNMediumLevelILOperation
  = MLIL_NOP
  | MLIL_SET_VAR
  | MLIL_SET_VAR_FIELD
  | MLIL_SET_VAR_SPLIT
  | MLIL_ASSERT
  | MLIL_FORCE_VER
  | MLIL_LOAD
  | MLIL_LOAD_STRUCT
  | MLIL_STORE
  | MLIL_STORE_STRUCT
  | MLIL_VAR
  | MLIL_VAR_FIELD
  | MLIL_VAR_SPLIT
  | MLIL_ADDRESS_OF
  | MLIL_ADDRESS_OF_FIELD
  | MLIL_PASS_BY_REF
  | MLIL_RETURN_BY_REF
  | MLIL_CONST
  | MLIL_CONST_DATA
  | MLIL_CONST_PTR
  | MLIL_EXTERN_PTR
  | MLIL_FLOAT_CONST
  | MLIL_IMPORT
  | MLIL_ADD
  | MLIL_ADC
  | MLIL_SUB
  | MLIL_SBB
  | MLIL_AND
  | MLIL_OR
  | MLIL_XOR
  | MLIL_LSL
  | MLIL_LSR
  | MLIL_ASR
  | MLIL_ROL
  | MLIL_RLC
  | MLIL_ROR
  | MLIL_RRC
  | MLIL_MUL
  | MLIL_MULU_DP
  | MLIL_MULS_DP
  | MLIL_DIVU
  | MLIL_DIVU_DP
  | MLIL_DIVS
  | MLIL_DIVS_DP
  | MLIL_MODU
  | MLIL_MODU_DP
  | MLIL_MODS
  | MLIL_MODS_DP
  | MLIL_NEG
  | MLIL_NOT
  | MLIL_SX
  | MLIL_ZX
  | MLIL_LOW_PART
  | MLIL_JUMP
  | MLIL_JUMP_TO
  | MLIL_RET_HINT
  | MLIL_CALL
  | MLIL_CALL_UNTYPED
  | MLIL_CALL_PARAM
  | MLIL_SEPARATE_PARAM_LIST
  | MLIL_SHARED_PARAM_SLOT
  | MLIL_VAR_OUTPUT
  | MLIL_VAR_OUTPUT_FIELD
  | MLIL_STORE_OUTPUT
  | MLIL_RET
  | MLIL_NORET
  | MLIL_IF
  | MLIL_GOTO
  | MLIL_CMP_E
  | MLIL_CMP_NE
  | MLIL_CMP_SLT
  | MLIL_CMP_ULT
  | MLIL_CMP_SLE
  | MLIL_CMP_ULE
  | MLIL_CMP_SGE
  | MLIL_CMP_UGE
  | MLIL_CMP_SGT
  | MLIL_CMP_UGT
  | MLIL_TEST_BIT
  | MLIL_BOOL_TO_INT
  | MLIL_ADD_OVERFLOW
  | MLIL_SYSCALL
  | MLIL_SYSCALL_UNTYPED
  | MLIL_TAILCALL
  | MLIL_TAILCALL_UNTYPED
  | MLIL_INTRINSIC
  | MLIL_FREE_VAR_SLOT
  | MLIL_BP
  | MLIL_TRAP
  | MLIL_UNDEF
  | MLIL_UNIMPL
  | MLIL_UNIMPL_MEM
  | MLIL_FADD
  | MLIL_FSUB
  | MLIL_FMUL
  | MLIL_FDIV
  | MLIL_FSQRT
  | MLIL_FNEG
  | MLIL_FABS
  | MLIL_FLOAT_TO_INT
  | MLIL_INT_TO_FLOAT
  | MLIL_FLOAT_CONV
  | MLIL_ROUND_TO_INT
  | MLIL_FLOOR
  | MLIL_CEIL
  | MLIL_FTRUNC
  | MLIL_FCMP_E
  | MLIL_FCMP_NE
  | MLIL_FCMP_LT
  | MLIL_FCMP_LE
  | MLIL_FCMP_GE
  | MLIL_FCMP_GT
  | MLIL_FCMP_O
  | MLIL_FCMP_UO
  | MLIL_SET_VAR_SSA
  | MLIL_SET_VAR_SSA_FIELD
  | MLIL_SET_VAR_SPLIT_SSA
  | MLIL_SET_VAR_ALIASED
  | MLIL_SET_VAR_ALIASED_FIELD
  | MLIL_VAR_SSA
  | MLIL_VAR_SSA_FIELD
  | MLIL_VAR_ALIASED
  | MLIL_VAR_ALIASED_FIELD
  | MLIL_VAR_SPLIT_SSA
  | MLIL_ASSERT_SSA
  | MLIL_FORCE_VER_SSA
  | MLIL_CALL_SSA
  | MLIL_CALL_UNTYPED_SSA
  | MLIL_SYSCALL_SSA
  | MLIL_SYSCALL_UNTYPED_SSA
  | MLIL_TAILCALL_SSA
  | MLIL_TAILCALL_UNTYPED_SSA
  | MLIL_CALL_PARAM_SSA
  | MLIL_CALL_OUTPUT_SSA
  | MLIL_VAR_OUTPUT_SSA
  | MLIL_VAR_OUTPUT_SSA_FIELD
  | MLIL_VAR_OUTPUT_ALIASED
  | MLIL_VAR_OUTPUT_ALIASED_FIELD
  | MLIL_MEMORY_INTRINSIC_OUTPUT_SSA
  | MLIL_LOAD_SSA
  | MLIL_LOAD_STRUCT_SSA
  | MLIL_STORE_SSA
  | MLIL_STORE_STRUCT_SSA
  | MLIL_INTRINSIC_SSA
  | MLIL_MEMORY_INTRINSIC_SSA
  | MLIL_FREE_VAR_SLOT_SSA
  | MLIL_VAR_PHI
  | MLIL_MEM_PHI
  | MLIL_BLOCK_TO_EXPAND
  | MLIL_BSWAP
  | MLIL_POPCNT
  | MLIL_CLZ
  | MLIL_CTZ
  | MLIL_RBIT
  | MLIL_CLS
  | MLIL_MINS
  | MLIL_MAXS
  | MLIL_MINU
  | MLIL_MAXU
  | MLIL_ABS
  deriving (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
(BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> Eq BNMediumLevelILOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
== :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
$c/= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
/= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
Eq, Eq BNMediumLevelILOperation
Eq BNMediumLevelILOperation =>
(BNMediumLevelILOperation -> BNMediumLevelILOperation -> Ordering)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool)
-> (BNMediumLevelILOperation
    -> BNMediumLevelILOperation -> BNMediumLevelILOperation)
-> (BNMediumLevelILOperation
    -> BNMediumLevelILOperation -> BNMediumLevelILOperation)
-> Ord BNMediumLevelILOperation
BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
BNMediumLevelILOperation -> BNMediumLevelILOperation -> Ordering
BNMediumLevelILOperation
-> BNMediumLevelILOperation -> BNMediumLevelILOperation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Ordering
compare :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Ordering
$c< :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
< :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
$c<= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
<= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
$c> :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
> :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
$c>= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
>= :: BNMediumLevelILOperation -> BNMediumLevelILOperation -> Bool
$cmax :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> BNMediumLevelILOperation
max :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> BNMediumLevelILOperation
$cmin :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> BNMediumLevelILOperation
min :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> BNMediumLevelILOperation
Ord, Int -> BNMediumLevelILOperation -> ShowS
[BNMediumLevelILOperation] -> ShowS
BNMediumLevelILOperation -> String
(Int -> BNMediumLevelILOperation -> ShowS)
-> (BNMediumLevelILOperation -> String)
-> ([BNMediumLevelILOperation] -> ShowS)
-> Show BNMediumLevelILOperation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNMediumLevelILOperation -> ShowS
showsPrec :: Int -> BNMediumLevelILOperation -> ShowS
$cshow :: BNMediumLevelILOperation -> String
show :: BNMediumLevelILOperation -> String
$cshowList :: [BNMediumLevelILOperation] -> ShowS
showList :: [BNMediumLevelILOperation] -> ShowS
Show, Int -> BNMediumLevelILOperation
BNMediumLevelILOperation -> Int
BNMediumLevelILOperation -> [BNMediumLevelILOperation]
BNMediumLevelILOperation -> BNMediumLevelILOperation
BNMediumLevelILOperation
-> BNMediumLevelILOperation -> [BNMediumLevelILOperation]
BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> [BNMediumLevelILOperation]
(BNMediumLevelILOperation -> BNMediumLevelILOperation)
-> (BNMediumLevelILOperation -> BNMediumLevelILOperation)
-> (Int -> BNMediumLevelILOperation)
-> (BNMediumLevelILOperation -> Int)
-> (BNMediumLevelILOperation -> [BNMediumLevelILOperation])
-> (BNMediumLevelILOperation
    -> BNMediumLevelILOperation -> [BNMediumLevelILOperation])
-> (BNMediumLevelILOperation
    -> BNMediumLevelILOperation -> [BNMediumLevelILOperation])
-> (BNMediumLevelILOperation
    -> BNMediumLevelILOperation
    -> BNMediumLevelILOperation
    -> [BNMediumLevelILOperation])
-> Enum BNMediumLevelILOperation
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNMediumLevelILOperation -> BNMediumLevelILOperation
succ :: BNMediumLevelILOperation -> BNMediumLevelILOperation
$cpred :: BNMediumLevelILOperation -> BNMediumLevelILOperation
pred :: BNMediumLevelILOperation -> BNMediumLevelILOperation
$ctoEnum :: Int -> BNMediumLevelILOperation
toEnum :: Int -> BNMediumLevelILOperation
$cfromEnum :: BNMediumLevelILOperation -> Int
fromEnum :: BNMediumLevelILOperation -> Int
$cenumFrom :: BNMediumLevelILOperation -> [BNMediumLevelILOperation]
enumFrom :: BNMediumLevelILOperation -> [BNMediumLevelILOperation]
$cenumFromThen :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> [BNMediumLevelILOperation]
enumFromThen :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> [BNMediumLevelILOperation]
$cenumFromTo :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> [BNMediumLevelILOperation]
enumFromTo :: BNMediumLevelILOperation
-> BNMediumLevelILOperation -> [BNMediumLevelILOperation]
$cenumFromThenTo :: BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> [BNMediumLevelILOperation]
enumFromThenTo :: BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> BNMediumLevelILOperation
-> [BNMediumLevelILOperation]
Enum)

data BNMediumLevelILInstruction = BNMediumLevelILInstruction
  { BNMediumLevelILInstruction -> BNMediumLevelILOperation
mlOperation :: !BNMediumLevelILOperation,
    BNMediumLevelILInstruction -> Word32
mlAttributes :: !Word32,
    BNMediumLevelILInstruction -> Word32
mlSourceOperand :: !Word32,
    BNMediumLevelILInstruction -> CSize
mlSize :: !CSize,
    BNMediumLevelILInstruction -> Word64
mlOp0 :: !Word64,
    BNMediumLevelILInstruction -> Word64
mlOp1 :: !Word64,
    BNMediumLevelILInstruction -> Word64
mlOp2 :: !Word64,
    BNMediumLevelILInstruction -> Word64
mlOp3 :: !Word64,
    BNMediumLevelILInstruction -> Word64
mlOp4 :: !Word64,
    BNMediumLevelILInstruction -> Word64
mlAddress :: !Word64
  }
  deriving (BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
(BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> Bool)
-> Eq BNMediumLevelILInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
== :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
$c/= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
/= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
Eq, Eq BNMediumLevelILInstruction
Eq BNMediumLevelILInstruction =>
(BNMediumLevelILInstruction
 -> BNMediumLevelILInstruction -> Ordering)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> Bool)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> Bool)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> Bool)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> Bool)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> BNMediumLevelILInstruction)
-> (BNMediumLevelILInstruction
    -> BNMediumLevelILInstruction -> BNMediumLevelILInstruction)
-> Ord BNMediumLevelILInstruction
BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> Ordering
BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> BNMediumLevelILInstruction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> Ordering
compare :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> Ordering
$c< :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
< :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
$c<= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
<= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
$c> :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
> :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
$c>= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
>= :: BNMediumLevelILInstruction -> BNMediumLevelILInstruction -> Bool
$cmax :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> BNMediumLevelILInstruction
max :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> BNMediumLevelILInstruction
$cmin :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> BNMediumLevelILInstruction
min :: BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> BNMediumLevelILInstruction
Ord, Int -> BNMediumLevelILInstruction -> ShowS
[BNMediumLevelILInstruction] -> ShowS
BNMediumLevelILInstruction -> String
(Int -> BNMediumLevelILInstruction -> ShowS)
-> (BNMediumLevelILInstruction -> String)
-> ([BNMediumLevelILInstruction] -> ShowS)
-> Show BNMediumLevelILInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNMediumLevelILInstruction -> ShowS
showsPrec :: Int -> BNMediumLevelILInstruction -> ShowS
$cshow :: BNMediumLevelILInstruction -> String
show :: BNMediumLevelILInstruction -> String
$cshowList :: [BNMediumLevelILInstruction] -> ShowS
showList :: [BNMediumLevelILInstruction] -> ShowS
Show)

instance Storable BNMediumLevelILInstruction where
  sizeOf :: BNMediumLevelILInstruction -> Int
sizeOf BNMediumLevelILInstruction
_ = Int
72
  alignment :: BNMediumLevelILInstruction -> Int
alignment BNMediumLevelILInstruction
_ = Int
Binja.Types.Core.alignmentS
  peek :: Ptr BNMediumLevelILInstruction -> IO BNMediumLevelILInstruction
peek Ptr BNMediumLevelILInstruction
ptr = do
    op <- Ptr BNMediumLevelILInstruction -> Int -> IO Word8
forall b. Ptr b -> Int -> IO Word8
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNMediumLevelILInstruction
ptr Int
0 :: IO Word8
    attr <- peekByteOff ptr 4 :: IO Word32
    srcOp <- peekByteOff ptr 8 :: IO Word32
    sz <- peekByteOff ptr 16 :: IO CSize
    o0 <- peekByteOff ptr 24 :: IO Word64
    o1 <- peekByteOff ptr 32 :: IO Word64
    o2 <- peekByteOff ptr 40 :: IO Word64
    o3 <- peekByteOff ptr 48 :: IO Word64
    o4 <- peekByteOff ptr 56 :: IO Word64
    addr <- peekByteOff ptr 64 :: IO Word64
    pure
      ( BNMediumLevelILInstruction
          (toEnum $ fromIntegral op)
          attr
          srcOp
          sz
          o0
          o1
          o2
          o3
          o4
          addr
      )
  poke :: Ptr BNMediumLevelILInstruction
-> BNMediumLevelILInstruction -> IO ()
poke Ptr BNMediumLevelILInstruction
ptr (BNMediumLevelILInstruction BNMediumLevelILOperation
op Word32
attr Word32
srcOp CSize
sz Word64
o0 Word64
o1 Word64
o2 Word64
o3 Word64
o4 Word64
addr) = do
    Ptr BNMediumLevelILInstruction -> Int -> Int -> IO ()
forall b. Ptr b -> Int -> Int -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
0 (Int -> IO ()) -> Int -> IO ()
forall a b. (a -> b) -> a -> b
$ BNMediumLevelILOperation -> Int
forall a. Enum a => a -> Int
fromEnum BNMediumLevelILOperation
op
    Ptr BNMediumLevelILInstruction -> Int -> Word32 -> IO ()
forall b. Ptr b -> Int -> Word32 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
4 Word32
attr
    Ptr BNMediumLevelILInstruction -> Int -> Word32 -> IO ()
forall b. Ptr b -> Int -> Word32 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
8 Word32
srcOp
    Ptr BNMediumLevelILInstruction -> Int -> CSize -> IO ()
forall b. Ptr b -> Int -> CSize -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
16 CSize
sz
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
24 Word64
o0
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
32 Word64
o1
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
40 Word64
o2
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
48 Word64
o3
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
56 Word64
o4
    Ptr BNMediumLevelILInstruction -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNMediumLevelILInstruction
ptr Int
64 Word64
addr

data CoreMediumLevelILInstruction = CoreMediumLevelILInstruction
  { CoreMediumLevelILInstruction -> BNMediumLevelILInstruction
instr :: BNMediumLevelILInstruction,
    CoreMediumLevelILInstruction -> BNMlilSSAFunctionPtr
ilFunc :: BNMlilSSAFunctionPtr,
    CoreMediumLevelILInstruction -> CSize
exprIndex :: CSize
  }
  deriving (Int -> CoreMediumLevelILInstruction -> ShowS
[CoreMediumLevelILInstruction] -> ShowS
CoreMediumLevelILInstruction -> String
(Int -> CoreMediumLevelILInstruction -> ShowS)
-> (CoreMediumLevelILInstruction -> String)
-> ([CoreMediumLevelILInstruction] -> ShowS)
-> Show CoreMediumLevelILInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CoreMediumLevelILInstruction -> ShowS
showsPrec :: Int -> CoreMediumLevelILInstruction -> ShowS
$cshow :: CoreMediumLevelILInstruction -> String
show :: CoreMediumLevelILInstruction -> String
$cshowList :: [CoreMediumLevelILInstruction] -> ShowS
showList :: [CoreMediumLevelILInstruction] -> ShowS
Show, CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
(CoreMediumLevelILInstruction
 -> CoreMediumLevelILInstruction -> Bool)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> Bool)
-> Eq CoreMediumLevelILInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
== :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
$c/= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
/= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
Eq, Eq CoreMediumLevelILInstruction
Eq CoreMediumLevelILInstruction =>
(CoreMediumLevelILInstruction
 -> CoreMediumLevelILInstruction -> Ordering)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> Bool)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> Bool)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> Bool)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> Bool)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction)
-> (CoreMediumLevelILInstruction
    -> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction)
-> Ord CoreMediumLevelILInstruction
CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Ordering
CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Ordering
compare :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Ordering
$c< :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
< :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
$c<= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
<= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
$c> :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
> :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
$c>= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
>= :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> Bool
$cmax :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction
max :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction
$cmin :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction
min :: CoreMediumLevelILInstruction
-> CoreMediumLevelILInstruction -> CoreMediumLevelILInstruction
Ord)

data MediumLevelILNopRec = MediumLevelILNopRec
  {MediumLevelILNopRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction}
  deriving (Int -> MediumLevelILNopRec -> ShowS
[MediumLevelILNopRec] -> ShowS
MediumLevelILNopRec -> String
(Int -> MediumLevelILNopRec -> ShowS)
-> (MediumLevelILNopRec -> String)
-> ([MediumLevelILNopRec] -> ShowS)
-> Show MediumLevelILNopRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILNopRec -> ShowS
showsPrec :: Int -> MediumLevelILNopRec -> ShowS
$cshow :: MediumLevelILNopRec -> String
show :: MediumLevelILNopRec -> String
$cshowList :: [MediumLevelILNopRec] -> ShowS
showList :: [MediumLevelILNopRec] -> ShowS
Show, MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
(MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> (MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> Eq MediumLevelILNopRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
== :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
$c/= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
/= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
Eq, Eq MediumLevelILNopRec
Eq MediumLevelILNopRec =>
(MediumLevelILNopRec -> MediumLevelILNopRec -> Ordering)
-> (MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> (MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> (MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> (MediumLevelILNopRec -> MediumLevelILNopRec -> Bool)
-> (MediumLevelILNopRec
    -> MediumLevelILNopRec -> MediumLevelILNopRec)
-> (MediumLevelILNopRec
    -> MediumLevelILNopRec -> MediumLevelILNopRec)
-> Ord MediumLevelILNopRec
MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
MediumLevelILNopRec -> MediumLevelILNopRec -> Ordering
MediumLevelILNopRec -> MediumLevelILNopRec -> MediumLevelILNopRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILNopRec -> MediumLevelILNopRec -> Ordering
compare :: MediumLevelILNopRec -> MediumLevelILNopRec -> Ordering
$c< :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
< :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
$c<= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
<= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
$c> :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
> :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
$c>= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
>= :: MediumLevelILNopRec -> MediumLevelILNopRec -> Bool
$cmax :: MediumLevelILNopRec -> MediumLevelILNopRec -> MediumLevelILNopRec
max :: MediumLevelILNopRec -> MediumLevelILNopRec -> MediumLevelILNopRec
$cmin :: MediumLevelILNopRec -> MediumLevelILNopRec -> MediumLevelILNopRec
min :: MediumLevelILNopRec -> MediumLevelILNopRec -> MediumLevelILNopRec
Ord)

data MediumLevelILCallSsaRec = MediumLevelILCallSsaRec
  { MediumLevelILCallSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILCallSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILCallSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILCallSsaRec -> Int
srcMemory :: Int,
    MediumLevelILCallSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallSsaRec -> ShowS
[MediumLevelILCallSsaRec] -> ShowS
MediumLevelILCallSsaRec -> String
(Int -> MediumLevelILCallSsaRec -> ShowS)
-> (MediumLevelILCallSsaRec -> String)
-> ([MediumLevelILCallSsaRec] -> ShowS)
-> Show MediumLevelILCallSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILCallSsaRec -> ShowS
$cshow :: MediumLevelILCallSsaRec -> String
show :: MediumLevelILCallSsaRec -> String
$cshowList :: [MediumLevelILCallSsaRec] -> ShowS
showList :: [MediumLevelILCallSsaRec] -> ShowS
Show, MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
(MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> (MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> Eq MediumLevelILCallSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
== :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
$c/= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
/= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
Eq, Eq MediumLevelILCallSsaRec
Eq MediumLevelILCallSsaRec =>
(MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Ordering)
-> (MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> (MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> (MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> (MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool)
-> (MediumLevelILCallSsaRec
    -> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec)
-> (MediumLevelILCallSsaRec
    -> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec)
-> Ord MediumLevelILCallSsaRec
MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Ordering
MediumLevelILCallSsaRec
-> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Ordering
compare :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Ordering
$c< :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
< :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
$c<= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
<= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
$c> :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
> :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
$c>= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
>= :: MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec -> Bool
$cmax :: MediumLevelILCallSsaRec
-> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec
max :: MediumLevelILCallSsaRec
-> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec
$cmin :: MediumLevelILCallSsaRec
-> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec
min :: MediumLevelILCallSsaRec
-> MediumLevelILCallSsaRec -> MediumLevelILCallSsaRec
Ord)

data MediumLevelILCallOutputSsaRec = MediumLevelILCallOutputSsaRec
  { MediumLevelILCallOutputSsaRec -> Int
destMemory :: Int,
    MediumLevelILCallOutputSsaRec -> [BNSSAVariable]
dest :: [BNSSAVariable],
    MediumLevelILCallOutputSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallOutputSsaRec -> ShowS
[MediumLevelILCallOutputSsaRec] -> ShowS
MediumLevelILCallOutputSsaRec -> String
(Int -> MediumLevelILCallOutputSsaRec -> ShowS)
-> (MediumLevelILCallOutputSsaRec -> String)
-> ([MediumLevelILCallOutputSsaRec] -> ShowS)
-> Show MediumLevelILCallOutputSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallOutputSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILCallOutputSsaRec -> ShowS
$cshow :: MediumLevelILCallOutputSsaRec -> String
show :: MediumLevelILCallOutputSsaRec -> String
$cshowList :: [MediumLevelILCallOutputSsaRec] -> ShowS
showList :: [MediumLevelILCallOutputSsaRec] -> ShowS
Show, MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
(MediumLevelILCallOutputSsaRec
 -> MediumLevelILCallOutputSsaRec -> Bool)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> Bool)
-> Eq MediumLevelILCallOutputSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
== :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
$c/= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
/= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
Eq, Eq MediumLevelILCallOutputSsaRec
Eq MediumLevelILCallOutputSsaRec =>
(MediumLevelILCallOutputSsaRec
 -> MediumLevelILCallOutputSsaRec -> Ordering)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> Bool)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> Bool)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> Bool)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> Bool)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec)
-> (MediumLevelILCallOutputSsaRec
    -> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec)
-> Ord MediumLevelILCallOutputSsaRec
MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Ordering
MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Ordering
compare :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Ordering
$c< :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
< :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
$c<= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
<= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
$c> :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
> :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
$c>= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
>= :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> Bool
$cmax :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec
max :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec
$cmin :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec
min :: MediumLevelILCallOutputSsaRec
-> MediumLevelILCallOutputSsaRec -> MediumLevelILCallOutputSsaRec
Ord)

data MediumLevelILVarOutputSsaRec = MediumLevelILVarOutputSsaRec
  { MediumLevelILVarOutputSsaRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILVarOutputSsaRec -> BNSSAVariable
var :: BNSSAVariable,
    MediumLevelILVarOutputSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputSsaRec -> ShowS
[MediumLevelILVarOutputSsaRec] -> ShowS
MediumLevelILVarOutputSsaRec -> String
(Int -> MediumLevelILVarOutputSsaRec -> ShowS)
-> (MediumLevelILVarOutputSsaRec -> String)
-> ([MediumLevelILVarOutputSsaRec] -> ShowS)
-> Show MediumLevelILVarOutputSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputSsaRec -> ShowS
$cshow :: MediumLevelILVarOutputSsaRec -> String
show :: MediumLevelILVarOutputSsaRec -> String
$cshowList :: [MediumLevelILVarOutputSsaRec] -> ShowS
showList :: [MediumLevelILVarOutputSsaRec] -> ShowS
Show, MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
(MediumLevelILVarOutputSsaRec
 -> MediumLevelILVarOutputSsaRec -> Bool)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> Bool)
-> Eq MediumLevelILVarOutputSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
== :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
$c/= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
/= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
Eq, Eq MediumLevelILVarOutputSsaRec
Eq MediumLevelILVarOutputSsaRec =>
(MediumLevelILVarOutputSsaRec
 -> MediumLevelILVarOutputSsaRec -> Ordering)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> Bool)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> Bool)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> Bool)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> Bool)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec)
-> (MediumLevelILVarOutputSsaRec
    -> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec)
-> Ord MediumLevelILVarOutputSsaRec
MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Ordering
MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Ordering
compare :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Ordering
$c< :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
< :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
$c<= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
<= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
$c> :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
> :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
$c>= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
>= :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> Bool
$cmax :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec
max :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec
$cmin :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec
min :: MediumLevelILVarOutputSsaRec
-> MediumLevelILVarOutputSsaRec -> MediumLevelILVarOutputSsaRec
Ord)

data MediumLevelILVarOutputSsaFieldRec = MediumLevelILVarOutputSsaFieldRec
  { MediumLevelILVarOutputSsaFieldRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILVarOutputSsaFieldRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILVarOutputSsaFieldRec -> Int
offset :: Int,
    MediumLevelILVarOutputSsaFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputSsaFieldRec -> ShowS
[MediumLevelILVarOutputSsaFieldRec] -> ShowS
MediumLevelILVarOutputSsaFieldRec -> String
(Int -> MediumLevelILVarOutputSsaFieldRec -> ShowS)
-> (MediumLevelILVarOutputSsaFieldRec -> String)
-> ([MediumLevelILVarOutputSsaFieldRec] -> ShowS)
-> Show MediumLevelILVarOutputSsaFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputSsaFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputSsaFieldRec -> ShowS
$cshow :: MediumLevelILVarOutputSsaFieldRec -> String
show :: MediumLevelILVarOutputSsaFieldRec -> String
$cshowList :: [MediumLevelILVarOutputSsaFieldRec] -> ShowS
showList :: [MediumLevelILVarOutputSsaFieldRec] -> ShowS
Show, MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
(MediumLevelILVarOutputSsaFieldRec
 -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> Eq MediumLevelILVarOutputSsaFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
== :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
$c/= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
/= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
Eq, Eq MediumLevelILVarOutputSsaFieldRec
Eq MediumLevelILVarOutputSsaFieldRec =>
(MediumLevelILVarOutputSsaFieldRec
 -> MediumLevelILVarOutputSsaFieldRec -> Ordering)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec -> Bool)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec)
-> (MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec
    -> MediumLevelILVarOutputSsaFieldRec)
-> Ord MediumLevelILVarOutputSsaFieldRec
MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Ordering
MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Ordering
compare :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Ordering
$c< :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
< :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
$c<= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
<= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
$c> :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
> :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
$c>= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
>= :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec -> Bool
$cmax :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
max :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
$cmin :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
min :: MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
-> MediumLevelILVarOutputSsaFieldRec
Ord)

data MediumLevelILVarOutputAliasedRec = MediumLevelILVarOutputAliasedRec
  { MediumLevelILVarOutputAliasedRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILVarOutputAliasedRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILVarOutputAliasedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputAliasedRec -> ShowS
[MediumLevelILVarOutputAliasedRec] -> ShowS
MediumLevelILVarOutputAliasedRec -> String
(Int -> MediumLevelILVarOutputAliasedRec -> ShowS)
-> (MediumLevelILVarOutputAliasedRec -> String)
-> ([MediumLevelILVarOutputAliasedRec] -> ShowS)
-> Show MediumLevelILVarOutputAliasedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputAliasedRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputAliasedRec -> ShowS
$cshow :: MediumLevelILVarOutputAliasedRec -> String
show :: MediumLevelILVarOutputAliasedRec -> String
$cshowList :: [MediumLevelILVarOutputAliasedRec] -> ShowS
showList :: [MediumLevelILVarOutputAliasedRec] -> ShowS
Show, MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
(MediumLevelILVarOutputAliasedRec
 -> MediumLevelILVarOutputAliasedRec -> Bool)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec -> Bool)
-> Eq MediumLevelILVarOutputAliasedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
== :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
$c/= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
/= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
Eq, Eq MediumLevelILVarOutputAliasedRec
Eq MediumLevelILVarOutputAliasedRec =>
(MediumLevelILVarOutputAliasedRec
 -> MediumLevelILVarOutputAliasedRec -> Ordering)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec -> Bool)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec -> Bool)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec -> Bool)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec -> Bool)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec)
-> (MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec
    -> MediumLevelILVarOutputAliasedRec)
-> Ord MediumLevelILVarOutputAliasedRec
MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Ordering
MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Ordering
compare :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Ordering
$c< :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
< :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
$c<= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
<= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
$c> :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
> :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
$c>= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
>= :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec -> Bool
$cmax :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
max :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
$cmin :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
min :: MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
-> MediumLevelILVarOutputAliasedRec
Ord)

data MediumLevelILVarOutputAliasedFieldRec = MediumLevelILVarOutputAliasedFieldRec
  { MediumLevelILVarOutputAliasedFieldRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILVarOutputAliasedFieldRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILVarOutputAliasedFieldRec -> Int
offset :: Int,
    MediumLevelILVarOutputAliasedFieldRec
-> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputAliasedFieldRec -> ShowS
[MediumLevelILVarOutputAliasedFieldRec] -> ShowS
MediumLevelILVarOutputAliasedFieldRec -> String
(Int -> MediumLevelILVarOutputAliasedFieldRec -> ShowS)
-> (MediumLevelILVarOutputAliasedFieldRec -> String)
-> ([MediumLevelILVarOutputAliasedFieldRec] -> ShowS)
-> Show MediumLevelILVarOutputAliasedFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputAliasedFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputAliasedFieldRec -> ShowS
$cshow :: MediumLevelILVarOutputAliasedFieldRec -> String
show :: MediumLevelILVarOutputAliasedFieldRec -> String
$cshowList :: [MediumLevelILVarOutputAliasedFieldRec] -> ShowS
showList :: [MediumLevelILVarOutputAliasedFieldRec] -> ShowS
Show, MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
(MediumLevelILVarOutputAliasedFieldRec
 -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> Eq MediumLevelILVarOutputAliasedFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
== :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
$c/= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
/= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
Eq, Eq MediumLevelILVarOutputAliasedFieldRec
Eq MediumLevelILVarOutputAliasedFieldRec =>
(MediumLevelILVarOutputAliasedFieldRec
 -> MediumLevelILVarOutputAliasedFieldRec -> Ordering)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec -> Bool)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec)
-> (MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec
    -> MediumLevelILVarOutputAliasedFieldRec)
-> Ord MediumLevelILVarOutputAliasedFieldRec
MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Ordering
MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Ordering
compare :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Ordering
$c< :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
< :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
$c<= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
<= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
$c> :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
> :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
$c>= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
>= :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec -> Bool
$cmax :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
max :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
$cmin :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
min :: MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
-> MediumLevelILVarOutputAliasedFieldRec
Ord)

data MediumLevelILCallParamSsaRec = MediumLevelILCallParamSsaRec
  { MediumLevelILCallParamSsaRec -> Int
srcMemory :: Int,
    MediumLevelILCallParamSsaRec -> [MediumLevelILSSAInstruction]
src :: [MediumLevelILSSAInstruction],
    MediumLevelILCallParamSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallParamSsaRec -> ShowS
[MediumLevelILCallParamSsaRec] -> ShowS
MediumLevelILCallParamSsaRec -> String
(Int -> MediumLevelILCallParamSsaRec -> ShowS)
-> (MediumLevelILCallParamSsaRec -> String)
-> ([MediumLevelILCallParamSsaRec] -> ShowS)
-> Show MediumLevelILCallParamSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallParamSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILCallParamSsaRec -> ShowS
$cshow :: MediumLevelILCallParamSsaRec -> String
show :: MediumLevelILCallParamSsaRec -> String
$cshowList :: [MediumLevelILCallParamSsaRec] -> ShowS
showList :: [MediumLevelILCallParamSsaRec] -> ShowS
Show, MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
(MediumLevelILCallParamSsaRec
 -> MediumLevelILCallParamSsaRec -> Bool)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> Bool)
-> Eq MediumLevelILCallParamSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
== :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
$c/= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
/= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
Eq, Eq MediumLevelILCallParamSsaRec
Eq MediumLevelILCallParamSsaRec =>
(MediumLevelILCallParamSsaRec
 -> MediumLevelILCallParamSsaRec -> Ordering)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> Bool)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> Bool)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> Bool)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> Bool)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec)
-> (MediumLevelILCallParamSsaRec
    -> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec)
-> Ord MediumLevelILCallParamSsaRec
MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Ordering
MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Ordering
compare :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Ordering
$c< :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
< :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
$c<= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
<= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
$c> :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
> :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
$c>= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
>= :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> Bool
$cmax :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec
max :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec
$cmin :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec
min :: MediumLevelILCallParamSsaRec
-> MediumLevelILCallParamSsaRec -> MediumLevelILCallParamSsaRec
Ord)

data MediumLevelILCallParamRec = MediumLevelILCallParamRec
  { MediumLevelILCallParamRec -> [MediumLevelILSSAInstruction]
src :: [MediumLevelILSSAInstruction],
    MediumLevelILCallParamRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallParamRec -> ShowS
[MediumLevelILCallParamRec] -> ShowS
MediumLevelILCallParamRec -> String
(Int -> MediumLevelILCallParamRec -> ShowS)
-> (MediumLevelILCallParamRec -> String)
-> ([MediumLevelILCallParamRec] -> ShowS)
-> Show MediumLevelILCallParamRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallParamRec -> ShowS
showsPrec :: Int -> MediumLevelILCallParamRec -> ShowS
$cshow :: MediumLevelILCallParamRec -> String
show :: MediumLevelILCallParamRec -> String
$cshowList :: [MediumLevelILCallParamRec] -> ShowS
showList :: [MediumLevelILCallParamRec] -> ShowS
Show, MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
(MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> (MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> Eq MediumLevelILCallParamRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
== :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
$c/= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
/= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
Eq, Eq MediumLevelILCallParamRec
Eq MediumLevelILCallParamRec =>
(MediumLevelILCallParamRec
 -> MediumLevelILCallParamRec -> Ordering)
-> (MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> (MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> (MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> (MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool)
-> (MediumLevelILCallParamRec
    -> MediumLevelILCallParamRec -> MediumLevelILCallParamRec)
-> (MediumLevelILCallParamRec
    -> MediumLevelILCallParamRec -> MediumLevelILCallParamRec)
-> Ord MediumLevelILCallParamRec
MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Ordering
MediumLevelILCallParamRec
-> MediumLevelILCallParamRec -> MediumLevelILCallParamRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Ordering
compare :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Ordering
$c< :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
< :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
$c<= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
<= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
$c> :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
> :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
$c>= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
>= :: MediumLevelILCallParamRec -> MediumLevelILCallParamRec -> Bool
$cmax :: MediumLevelILCallParamRec
-> MediumLevelILCallParamRec -> MediumLevelILCallParamRec
max :: MediumLevelILCallParamRec
-> MediumLevelILCallParamRec -> MediumLevelILCallParamRec
$cmin :: MediumLevelILCallParamRec
-> MediumLevelILCallParamRec -> MediumLevelILCallParamRec
min :: MediumLevelILCallParamRec
-> MediumLevelILCallParamRec -> MediumLevelILCallParamRec
Ord)

data MediumLevelILConstPtrRec = MediumLevelILConstPtrRec
  { MediumLevelILConstPtrRec -> Int
constant :: Int,
    MediumLevelILConstPtrRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILConstPtrRec -> ShowS
[MediumLevelILConstPtrRec] -> ShowS
MediumLevelILConstPtrRec -> String
(Int -> MediumLevelILConstPtrRec -> ShowS)
-> (MediumLevelILConstPtrRec -> String)
-> ([MediumLevelILConstPtrRec] -> ShowS)
-> Show MediumLevelILConstPtrRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILConstPtrRec -> ShowS
showsPrec :: Int -> MediumLevelILConstPtrRec -> ShowS
$cshow :: MediumLevelILConstPtrRec -> String
show :: MediumLevelILConstPtrRec -> String
$cshowList :: [MediumLevelILConstPtrRec] -> ShowS
showList :: [MediumLevelILConstPtrRec] -> ShowS
Show, MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
(MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> (MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> Eq MediumLevelILConstPtrRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
== :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
$c/= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
/= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
Eq, Eq MediumLevelILConstPtrRec
Eq MediumLevelILConstPtrRec =>
(MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Ordering)
-> (MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> (MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> (MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> (MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool)
-> (MediumLevelILConstPtrRec
    -> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec)
-> (MediumLevelILConstPtrRec
    -> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec)
-> Ord MediumLevelILConstPtrRec
MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Ordering
MediumLevelILConstPtrRec
-> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Ordering
compare :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Ordering
$c< :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
< :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
$c<= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
<= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
$c> :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
> :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
$c>= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
>= :: MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec -> Bool
$cmax :: MediumLevelILConstPtrRec
-> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec
max :: MediumLevelILConstPtrRec
-> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec
$cmin :: MediumLevelILConstPtrRec
-> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec
min :: MediumLevelILConstPtrRec
-> MediumLevelILConstPtrRec -> MediumLevelILConstPtrRec
Ord)

data MediumLevelILConstRec = MediumLevelILConstRec
  { MediumLevelILConstRec -> Int
constant :: Int,
    MediumLevelILConstRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILConstRec -> ShowS
[MediumLevelILConstRec] -> ShowS
MediumLevelILConstRec -> String
(Int -> MediumLevelILConstRec -> ShowS)
-> (MediumLevelILConstRec -> String)
-> ([MediumLevelILConstRec] -> ShowS)
-> Show MediumLevelILConstRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILConstRec -> ShowS
showsPrec :: Int -> MediumLevelILConstRec -> ShowS
$cshow :: MediumLevelILConstRec -> String
show :: MediumLevelILConstRec -> String
$cshowList :: [MediumLevelILConstRec] -> ShowS
showList :: [MediumLevelILConstRec] -> ShowS
Show, MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
(MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> (MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> Eq MediumLevelILConstRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
== :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
$c/= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
/= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
Eq, Eq MediumLevelILConstRec
Eq MediumLevelILConstRec =>
(MediumLevelILConstRec -> MediumLevelILConstRec -> Ordering)
-> (MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> (MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> (MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> (MediumLevelILConstRec -> MediumLevelILConstRec -> Bool)
-> (MediumLevelILConstRec
    -> MediumLevelILConstRec -> MediumLevelILConstRec)
-> (MediumLevelILConstRec
    -> MediumLevelILConstRec -> MediumLevelILConstRec)
-> Ord MediumLevelILConstRec
MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
MediumLevelILConstRec -> MediumLevelILConstRec -> Ordering
MediumLevelILConstRec
-> MediumLevelILConstRec -> MediumLevelILConstRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILConstRec -> MediumLevelILConstRec -> Ordering
compare :: MediumLevelILConstRec -> MediumLevelILConstRec -> Ordering
$c< :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
< :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
$c<= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
<= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
$c> :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
> :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
$c>= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
>= :: MediumLevelILConstRec -> MediumLevelILConstRec -> Bool
$cmax :: MediumLevelILConstRec
-> MediumLevelILConstRec -> MediumLevelILConstRec
max :: MediumLevelILConstRec
-> MediumLevelILConstRec -> MediumLevelILConstRec
$cmin :: MediumLevelILConstRec
-> MediumLevelILConstRec -> MediumLevelILConstRec
min :: MediumLevelILConstRec
-> MediumLevelILConstRec -> MediumLevelILConstRec
Ord)

data MediumLevelILRetRec = MediumLevelILRetRec
  { MediumLevelILRetRec -> [MediumLevelILSSAInstruction]
src :: [MediumLevelILSSAInstruction],
    MediumLevelILRetRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRetRec -> ShowS
[MediumLevelILRetRec] -> ShowS
MediumLevelILRetRec -> String
(Int -> MediumLevelILRetRec -> ShowS)
-> (MediumLevelILRetRec -> String)
-> ([MediumLevelILRetRec] -> ShowS)
-> Show MediumLevelILRetRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRetRec -> ShowS
showsPrec :: Int -> MediumLevelILRetRec -> ShowS
$cshow :: MediumLevelILRetRec -> String
show :: MediumLevelILRetRec -> String
$cshowList :: [MediumLevelILRetRec] -> ShowS
showList :: [MediumLevelILRetRec] -> ShowS
Show, MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
(MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> (MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> Eq MediumLevelILRetRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
== :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
$c/= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
/= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
Eq, Eq MediumLevelILRetRec
Eq MediumLevelILRetRec =>
(MediumLevelILRetRec -> MediumLevelILRetRec -> Ordering)
-> (MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> (MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> (MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> (MediumLevelILRetRec -> MediumLevelILRetRec -> Bool)
-> (MediumLevelILRetRec
    -> MediumLevelILRetRec -> MediumLevelILRetRec)
-> (MediumLevelILRetRec
    -> MediumLevelILRetRec -> MediumLevelILRetRec)
-> Ord MediumLevelILRetRec
MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
MediumLevelILRetRec -> MediumLevelILRetRec -> Ordering
MediumLevelILRetRec -> MediumLevelILRetRec -> MediumLevelILRetRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRetRec -> MediumLevelILRetRec -> Ordering
compare :: MediumLevelILRetRec -> MediumLevelILRetRec -> Ordering
$c< :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
< :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
$c<= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
<= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
$c> :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
> :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
$c>= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
>= :: MediumLevelILRetRec -> MediumLevelILRetRec -> Bool
$cmax :: MediumLevelILRetRec -> MediumLevelILRetRec -> MediumLevelILRetRec
max :: MediumLevelILRetRec -> MediumLevelILRetRec -> MediumLevelILRetRec
$cmin :: MediumLevelILRetRec -> MediumLevelILRetRec -> MediumLevelILRetRec
min :: MediumLevelILRetRec -> MediumLevelILRetRec -> MediumLevelILRetRec
Ord)

data MediumLevelILVarSsaRec = MediumLevelILVarSsaRec
  { MediumLevelILVarSsaRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILVarSsaRec -> BNSSAVariable
var :: BNSSAVariable,
    MediumLevelILVarSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarSsaRec -> ShowS
[MediumLevelILVarSsaRec] -> ShowS
MediumLevelILVarSsaRec -> String
(Int -> MediumLevelILVarSsaRec -> ShowS)
-> (MediumLevelILVarSsaRec -> String)
-> ([MediumLevelILVarSsaRec] -> ShowS)
-> Show MediumLevelILVarSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILVarSsaRec -> ShowS
$cshow :: MediumLevelILVarSsaRec -> String
show :: MediumLevelILVarSsaRec -> String
$cshowList :: [MediumLevelILVarSsaRec] -> ShowS
showList :: [MediumLevelILVarSsaRec] -> ShowS
Show, MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
(MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> (MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> Eq MediumLevelILVarSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
== :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
$c/= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
/= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
Eq, Eq MediumLevelILVarSsaRec
Eq MediumLevelILVarSsaRec =>
(MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Ordering)
-> (MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> (MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> (MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> (MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool)
-> (MediumLevelILVarSsaRec
    -> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec)
-> (MediumLevelILVarSsaRec
    -> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec)
-> Ord MediumLevelILVarSsaRec
MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Ordering
MediumLevelILVarSsaRec
-> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Ordering
compare :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Ordering
$c< :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
< :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
$c<= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
<= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
$c> :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
> :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
$c>= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
>= :: MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec -> Bool
$cmax :: MediumLevelILVarSsaRec
-> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec
max :: MediumLevelILVarSsaRec
-> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec
$cmin :: MediumLevelILVarSsaRec
-> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec
min :: MediumLevelILVarSsaRec
-> MediumLevelILVarSsaRec -> MediumLevelILVarSsaRec
Ord)

data MediumLevelILSetVarSsaRec = MediumLevelILSetVarSsaRec
  { MediumLevelILSetVarSsaRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILSetVarSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarSsaRec -> ShowS
[MediumLevelILSetVarSsaRec] -> ShowS
MediumLevelILSetVarSsaRec -> String
(Int -> MediumLevelILSetVarSsaRec -> ShowS)
-> (MediumLevelILSetVarSsaRec -> String)
-> ([MediumLevelILSetVarSsaRec] -> ShowS)
-> Show MediumLevelILSetVarSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarSsaRec -> ShowS
$cshow :: MediumLevelILSetVarSsaRec -> String
show :: MediumLevelILSetVarSsaRec -> String
$cshowList :: [MediumLevelILSetVarSsaRec] -> ShowS
showList :: [MediumLevelILSetVarSsaRec] -> ShowS
Show, MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
(MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> (MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> Eq MediumLevelILSetVarSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
== :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
$c/= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
/= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
Eq, Eq MediumLevelILSetVarSsaRec
Eq MediumLevelILSetVarSsaRec =>
(MediumLevelILSetVarSsaRec
 -> MediumLevelILSetVarSsaRec -> Ordering)
-> (MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> (MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> (MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> (MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool)
-> (MediumLevelILSetVarSsaRec
    -> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec)
-> (MediumLevelILSetVarSsaRec
    -> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec)
-> Ord MediumLevelILSetVarSsaRec
MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Ordering
MediumLevelILSetVarSsaRec
-> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Ordering
compare :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Ordering
$c< :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
< :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
$c<= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
<= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
$c> :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
> :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
$c>= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
>= :: MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec -> Bool
$cmax :: MediumLevelILSetVarSsaRec
-> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec
max :: MediumLevelILSetVarSsaRec
-> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec
$cmin :: MediumLevelILSetVarSsaRec
-> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec
min :: MediumLevelILSetVarSsaRec
-> MediumLevelILSetVarSsaRec -> MediumLevelILSetVarSsaRec
Ord)

data MediumLevelILJumpRec = MediumLevelILJumpRec
  { MediumLevelILJumpRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILJumpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILJumpRec -> ShowS
[MediumLevelILJumpRec] -> ShowS
MediumLevelILJumpRec -> String
(Int -> MediumLevelILJumpRec -> ShowS)
-> (MediumLevelILJumpRec -> String)
-> ([MediumLevelILJumpRec] -> ShowS)
-> Show MediumLevelILJumpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILJumpRec -> ShowS
showsPrec :: Int -> MediumLevelILJumpRec -> ShowS
$cshow :: MediumLevelILJumpRec -> String
show :: MediumLevelILJumpRec -> String
$cshowList :: [MediumLevelILJumpRec] -> ShowS
showList :: [MediumLevelILJumpRec] -> ShowS
Show, MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
(MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> (MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> Eq MediumLevelILJumpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
== :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
$c/= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
/= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
Eq, Eq MediumLevelILJumpRec
Eq MediumLevelILJumpRec =>
(MediumLevelILJumpRec -> MediumLevelILJumpRec -> Ordering)
-> (MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> (MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> (MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> (MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool)
-> (MediumLevelILJumpRec
    -> MediumLevelILJumpRec -> MediumLevelILJumpRec)
-> (MediumLevelILJumpRec
    -> MediumLevelILJumpRec -> MediumLevelILJumpRec)
-> Ord MediumLevelILJumpRec
MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
MediumLevelILJumpRec -> MediumLevelILJumpRec -> Ordering
MediumLevelILJumpRec
-> MediumLevelILJumpRec -> MediumLevelILJumpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Ordering
compare :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Ordering
$c< :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
< :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
$c<= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
<= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
$c> :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
> :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
$c>= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
>= :: MediumLevelILJumpRec -> MediumLevelILJumpRec -> Bool
$cmax :: MediumLevelILJumpRec
-> MediumLevelILJumpRec -> MediumLevelILJumpRec
max :: MediumLevelILJumpRec
-> MediumLevelILJumpRec -> MediumLevelILJumpRec
$cmin :: MediumLevelILJumpRec
-> MediumLevelILJumpRec -> MediumLevelILJumpRec
min :: MediumLevelILJumpRec
-> MediumLevelILJumpRec -> MediumLevelILJumpRec
Ord)

data MediumLevelILTailcallSsaRec = MediumLevelILTailcallSsaRec
  { MediumLevelILTailcallSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILTailcallSsaRec -> Int
outputDestMemory :: Int,
    MediumLevelILTailcallSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILTailcallSsaRec -> Int
srcMemory :: Int,
    MediumLevelILTailcallSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTailcallSsaRec -> ShowS
[MediumLevelILTailcallSsaRec] -> ShowS
MediumLevelILTailcallSsaRec -> String
(Int -> MediumLevelILTailcallSsaRec -> ShowS)
-> (MediumLevelILTailcallSsaRec -> String)
-> ([MediumLevelILTailcallSsaRec] -> ShowS)
-> Show MediumLevelILTailcallSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTailcallSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILTailcallSsaRec -> ShowS
$cshow :: MediumLevelILTailcallSsaRec -> String
show :: MediumLevelILTailcallSsaRec -> String
$cshowList :: [MediumLevelILTailcallSsaRec] -> ShowS
showList :: [MediumLevelILTailcallSsaRec] -> ShowS
Show, MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
(MediumLevelILTailcallSsaRec
 -> MediumLevelILTailcallSsaRec -> Bool)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> Bool)
-> Eq MediumLevelILTailcallSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
== :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
$c/= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
/= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
Eq, Eq MediumLevelILTailcallSsaRec
Eq MediumLevelILTailcallSsaRec =>
(MediumLevelILTailcallSsaRec
 -> MediumLevelILTailcallSsaRec -> Ordering)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> Bool)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> Bool)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> Bool)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> Bool)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec)
-> (MediumLevelILTailcallSsaRec
    -> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec)
-> Ord MediumLevelILTailcallSsaRec
MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> Ordering
MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> Ordering
compare :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> Ordering
$c< :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
< :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
$c<= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
<= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
$c> :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
> :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
$c>= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
>= :: MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec -> Bool
$cmax :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec
max :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec
$cmin :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec
min :: MediumLevelILTailcallSsaRec
-> MediumLevelILTailcallSsaRec -> MediumLevelILTailcallSsaRec
Ord)

data MediumLevelILImportRec = MediumLevelILImportRec
  { MediumLevelILImportRec -> Int
constant :: Int,
    MediumLevelILImportRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILImportRec -> ShowS
[MediumLevelILImportRec] -> ShowS
MediumLevelILImportRec -> String
(Int -> MediumLevelILImportRec -> ShowS)
-> (MediumLevelILImportRec -> String)
-> ([MediumLevelILImportRec] -> ShowS)
-> Show MediumLevelILImportRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILImportRec -> ShowS
showsPrec :: Int -> MediumLevelILImportRec -> ShowS
$cshow :: MediumLevelILImportRec -> String
show :: MediumLevelILImportRec -> String
$cshowList :: [MediumLevelILImportRec] -> ShowS
showList :: [MediumLevelILImportRec] -> ShowS
Show, MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
(MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> (MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> Eq MediumLevelILImportRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
== :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
$c/= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
/= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
Eq, Eq MediumLevelILImportRec
Eq MediumLevelILImportRec =>
(MediumLevelILImportRec -> MediumLevelILImportRec -> Ordering)
-> (MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> (MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> (MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> (MediumLevelILImportRec -> MediumLevelILImportRec -> Bool)
-> (MediumLevelILImportRec
    -> MediumLevelILImportRec -> MediumLevelILImportRec)
-> (MediumLevelILImportRec
    -> MediumLevelILImportRec -> MediumLevelILImportRec)
-> Ord MediumLevelILImportRec
MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
MediumLevelILImportRec -> MediumLevelILImportRec -> Ordering
MediumLevelILImportRec
-> MediumLevelILImportRec -> MediumLevelILImportRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILImportRec -> MediumLevelILImportRec -> Ordering
compare :: MediumLevelILImportRec -> MediumLevelILImportRec -> Ordering
$c< :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
< :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
$c<= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
<= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
$c> :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
> :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
$c>= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
>= :: MediumLevelILImportRec -> MediumLevelILImportRec -> Bool
$cmax :: MediumLevelILImportRec
-> MediumLevelILImportRec -> MediumLevelILImportRec
max :: MediumLevelILImportRec
-> MediumLevelILImportRec -> MediumLevelILImportRec
$cmin :: MediumLevelILImportRec
-> MediumLevelILImportRec -> MediumLevelILImportRec
min :: MediumLevelILImportRec
-> MediumLevelILImportRec -> MediumLevelILImportRec
Ord)

data MediumLevelILAddressOfRec = MediumLevelILAddressOfRec
  { MediumLevelILAddressOfRec -> BNVariable
src :: BNVariable,
    MediumLevelILAddressOfRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAddressOfRec -> ShowS
[MediumLevelILAddressOfRec] -> ShowS
MediumLevelILAddressOfRec -> String
(Int -> MediumLevelILAddressOfRec -> ShowS)
-> (MediumLevelILAddressOfRec -> String)
-> ([MediumLevelILAddressOfRec] -> ShowS)
-> Show MediumLevelILAddressOfRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAddressOfRec -> ShowS
showsPrec :: Int -> MediumLevelILAddressOfRec -> ShowS
$cshow :: MediumLevelILAddressOfRec -> String
show :: MediumLevelILAddressOfRec -> String
$cshowList :: [MediumLevelILAddressOfRec] -> ShowS
showList :: [MediumLevelILAddressOfRec] -> ShowS
Show, MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
(MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> (MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> Eq MediumLevelILAddressOfRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
== :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
$c/= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
/= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
Eq, Eq MediumLevelILAddressOfRec
Eq MediumLevelILAddressOfRec =>
(MediumLevelILAddressOfRec
 -> MediumLevelILAddressOfRec -> Ordering)
-> (MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> (MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> (MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> (MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool)
-> (MediumLevelILAddressOfRec
    -> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec)
-> (MediumLevelILAddressOfRec
    -> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec)
-> Ord MediumLevelILAddressOfRec
MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Ordering
MediumLevelILAddressOfRec
-> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Ordering
compare :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Ordering
$c< :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
< :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
$c<= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
<= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
$c> :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
> :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
$c>= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
>= :: MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec -> Bool
$cmax :: MediumLevelILAddressOfRec
-> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec
max :: MediumLevelILAddressOfRec
-> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec
$cmin :: MediumLevelILAddressOfRec
-> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec
min :: MediumLevelILAddressOfRec
-> MediumLevelILAddressOfRec -> MediumLevelILAddressOfRec
Ord)

data MediumLevelILAddressOfFieldRec = MediumLevelILAddressOfFieldRec
  { MediumLevelILAddressOfFieldRec -> BNVariable
src :: BNVariable,
    MediumLevelILAddressOfFieldRec -> Int
offset :: Int,
    MediumLevelILAddressOfFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAddressOfFieldRec -> ShowS
[MediumLevelILAddressOfFieldRec] -> ShowS
MediumLevelILAddressOfFieldRec -> String
(Int -> MediumLevelILAddressOfFieldRec -> ShowS)
-> (MediumLevelILAddressOfFieldRec -> String)
-> ([MediumLevelILAddressOfFieldRec] -> ShowS)
-> Show MediumLevelILAddressOfFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAddressOfFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILAddressOfFieldRec -> ShowS
$cshow :: MediumLevelILAddressOfFieldRec -> String
show :: MediumLevelILAddressOfFieldRec -> String
$cshowList :: [MediumLevelILAddressOfFieldRec] -> ShowS
showList :: [MediumLevelILAddressOfFieldRec] -> ShowS
Show, MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
(MediumLevelILAddressOfFieldRec
 -> MediumLevelILAddressOfFieldRec -> Bool)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec -> Bool)
-> Eq MediumLevelILAddressOfFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
== :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
$c/= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
/= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
Eq, Eq MediumLevelILAddressOfFieldRec
Eq MediumLevelILAddressOfFieldRec =>
(MediumLevelILAddressOfFieldRec
 -> MediumLevelILAddressOfFieldRec -> Ordering)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec -> Bool)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec -> Bool)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec -> Bool)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec -> Bool)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec)
-> (MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec
    -> MediumLevelILAddressOfFieldRec)
-> Ord MediumLevelILAddressOfFieldRec
MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Ordering
MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> MediumLevelILAddressOfFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Ordering
compare :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Ordering
$c< :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
< :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
$c<= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
<= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
$c> :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
> :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
$c>= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
>= :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> Bool
$cmax :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> MediumLevelILAddressOfFieldRec
max :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> MediumLevelILAddressOfFieldRec
$cmin :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> MediumLevelILAddressOfFieldRec
min :: MediumLevelILAddressOfFieldRec
-> MediumLevelILAddressOfFieldRec -> MediumLevelILAddressOfFieldRec
Ord)

data MediumLevelILPassByRefRec = MediumLevelILPassByRefRec
  { MediumLevelILPassByRefRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILPassByRefRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILPassByRefRec -> ShowS
[MediumLevelILPassByRefRec] -> ShowS
MediumLevelILPassByRefRec -> String
(Int -> MediumLevelILPassByRefRec -> ShowS)
-> (MediumLevelILPassByRefRec -> String)
-> ([MediumLevelILPassByRefRec] -> ShowS)
-> Show MediumLevelILPassByRefRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILPassByRefRec -> ShowS
showsPrec :: Int -> MediumLevelILPassByRefRec -> ShowS
$cshow :: MediumLevelILPassByRefRec -> String
show :: MediumLevelILPassByRefRec -> String
$cshowList :: [MediumLevelILPassByRefRec] -> ShowS
showList :: [MediumLevelILPassByRefRec] -> ShowS
Show, MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
(MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> (MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> Eq MediumLevelILPassByRefRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
== :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
$c/= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
/= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
Eq, Eq MediumLevelILPassByRefRec
Eq MediumLevelILPassByRefRec =>
(MediumLevelILPassByRefRec
 -> MediumLevelILPassByRefRec -> Ordering)
-> (MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> (MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> (MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> (MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool)
-> (MediumLevelILPassByRefRec
    -> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec)
-> (MediumLevelILPassByRefRec
    -> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec)
-> Ord MediumLevelILPassByRefRec
MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Ordering
MediumLevelILPassByRefRec
-> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Ordering
compare :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Ordering
$c< :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
< :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
$c<= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
<= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
$c> :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
> :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
$c>= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
>= :: MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec -> Bool
$cmax :: MediumLevelILPassByRefRec
-> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec
max :: MediumLevelILPassByRefRec
-> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec
$cmin :: MediumLevelILPassByRefRec
-> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec
min :: MediumLevelILPassByRefRec
-> MediumLevelILPassByRefRec -> MediumLevelILPassByRefRec
Ord)

data MediumLevelILReturnByRefRec = MediumLevelILReturnByRefRec
  { MediumLevelILReturnByRefRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILReturnByRefRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILReturnByRefRec -> ShowS
[MediumLevelILReturnByRefRec] -> ShowS
MediumLevelILReturnByRefRec -> String
(Int -> MediumLevelILReturnByRefRec -> ShowS)
-> (MediumLevelILReturnByRefRec -> String)
-> ([MediumLevelILReturnByRefRec] -> ShowS)
-> Show MediumLevelILReturnByRefRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILReturnByRefRec -> ShowS
showsPrec :: Int -> MediumLevelILReturnByRefRec -> ShowS
$cshow :: MediumLevelILReturnByRefRec -> String
show :: MediumLevelILReturnByRefRec -> String
$cshowList :: [MediumLevelILReturnByRefRec] -> ShowS
showList :: [MediumLevelILReturnByRefRec] -> ShowS
Show, MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
(MediumLevelILReturnByRefRec
 -> MediumLevelILReturnByRefRec -> Bool)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> Bool)
-> Eq MediumLevelILReturnByRefRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
== :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
$c/= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
/= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
Eq, Eq MediumLevelILReturnByRefRec
Eq MediumLevelILReturnByRefRec =>
(MediumLevelILReturnByRefRec
 -> MediumLevelILReturnByRefRec -> Ordering)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> Bool)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> Bool)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> Bool)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> Bool)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec)
-> (MediumLevelILReturnByRefRec
    -> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec)
-> Ord MediumLevelILReturnByRefRec
MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> Ordering
MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> Ordering
compare :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> Ordering
$c< :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
< :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
$c<= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
<= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
$c> :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
> :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
$c>= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
>= :: MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec -> Bool
$cmax :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec
max :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec
$cmin :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec
min :: MediumLevelILReturnByRefRec
-> MediumLevelILReturnByRefRec -> MediumLevelILReturnByRefRec
Ord)

data MediumLevelILLoadSsaRec = MediumLevelILLoadSsaRec
  { MediumLevelILLoadSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILLoadSsaRec -> Int
srcMemory :: Int,
    MediumLevelILLoadSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLoadSsaRec -> ShowS
[MediumLevelILLoadSsaRec] -> ShowS
MediumLevelILLoadSsaRec -> String
(Int -> MediumLevelILLoadSsaRec -> ShowS)
-> (MediumLevelILLoadSsaRec -> String)
-> ([MediumLevelILLoadSsaRec] -> ShowS)
-> Show MediumLevelILLoadSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLoadSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILLoadSsaRec -> ShowS
$cshow :: MediumLevelILLoadSsaRec -> String
show :: MediumLevelILLoadSsaRec -> String
$cshowList :: [MediumLevelILLoadSsaRec] -> ShowS
showList :: [MediumLevelILLoadSsaRec] -> ShowS
Show, MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
(MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> (MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> Eq MediumLevelILLoadSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
== :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
$c/= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
/= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
Eq, Eq MediumLevelILLoadSsaRec
Eq MediumLevelILLoadSsaRec =>
(MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Ordering)
-> (MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> (MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> (MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> (MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool)
-> (MediumLevelILLoadSsaRec
    -> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec)
-> (MediumLevelILLoadSsaRec
    -> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec)
-> Ord MediumLevelILLoadSsaRec
MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Ordering
MediumLevelILLoadSsaRec
-> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Ordering
compare :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Ordering
$c< :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
< :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
$c<= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
<= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
$c> :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
> :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
$c>= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
>= :: MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec -> Bool
$cmax :: MediumLevelILLoadSsaRec
-> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec
max :: MediumLevelILLoadSsaRec
-> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec
$cmin :: MediumLevelILLoadSsaRec
-> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec
min :: MediumLevelILLoadSsaRec
-> MediumLevelILLoadSsaRec -> MediumLevelILLoadSsaRec
Ord)

data MediumLevelILIfRec = MediumLevelILIfRec
  { MediumLevelILIfRec -> MediumLevelILSSAInstruction
condition :: MediumLevelILSSAInstruction,
    MediumLevelILIfRec -> Int
true :: Int, -- Instruction Index
    MediumLevelILIfRec -> Int
false :: Int, -- Instruction Index
    MediumLevelILIfRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILIfRec -> ShowS
[MediumLevelILIfRec] -> ShowS
MediumLevelILIfRec -> String
(Int -> MediumLevelILIfRec -> ShowS)
-> (MediumLevelILIfRec -> String)
-> ([MediumLevelILIfRec] -> ShowS)
-> Show MediumLevelILIfRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILIfRec -> ShowS
showsPrec :: Int -> MediumLevelILIfRec -> ShowS
$cshow :: MediumLevelILIfRec -> String
show :: MediumLevelILIfRec -> String
$cshowList :: [MediumLevelILIfRec] -> ShowS
showList :: [MediumLevelILIfRec] -> ShowS
Show, MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
(MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> Eq MediumLevelILIfRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
== :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
$c/= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
/= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
Eq, Eq MediumLevelILIfRec
Eq MediumLevelILIfRec =>
(MediumLevelILIfRec -> MediumLevelILIfRec -> Ordering)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> Bool)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec)
-> (MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec)
-> Ord MediumLevelILIfRec
MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
MediumLevelILIfRec -> MediumLevelILIfRec -> Ordering
MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILIfRec -> MediumLevelILIfRec -> Ordering
compare :: MediumLevelILIfRec -> MediumLevelILIfRec -> Ordering
$c< :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
< :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
$c<= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
<= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
$c> :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
> :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
$c>= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
>= :: MediumLevelILIfRec -> MediumLevelILIfRec -> Bool
$cmax :: MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec
max :: MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec
$cmin :: MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec
min :: MediumLevelILIfRec -> MediumLevelILIfRec -> MediumLevelILIfRec
Ord)

data MediumLevelILCmpERec = MediumLevelILCmpERec
  { MediumLevelILCmpERec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpERec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpERec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpERec -> ShowS
[MediumLevelILCmpERec] -> ShowS
MediumLevelILCmpERec -> String
(Int -> MediumLevelILCmpERec -> ShowS)
-> (MediumLevelILCmpERec -> String)
-> ([MediumLevelILCmpERec] -> ShowS)
-> Show MediumLevelILCmpERec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpERec -> ShowS
showsPrec :: Int -> MediumLevelILCmpERec -> ShowS
$cshow :: MediumLevelILCmpERec -> String
show :: MediumLevelILCmpERec -> String
$cshowList :: [MediumLevelILCmpERec] -> ShowS
showList :: [MediumLevelILCmpERec] -> ShowS
Show, MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
(MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> (MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> Eq MediumLevelILCmpERec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
== :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
$c/= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
/= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
Eq, Eq MediumLevelILCmpERec
Eq MediumLevelILCmpERec =>
(MediumLevelILCmpERec -> MediumLevelILCmpERec -> Ordering)
-> (MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> (MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> (MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> (MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool)
-> (MediumLevelILCmpERec
    -> MediumLevelILCmpERec -> MediumLevelILCmpERec)
-> (MediumLevelILCmpERec
    -> MediumLevelILCmpERec -> MediumLevelILCmpERec)
-> Ord MediumLevelILCmpERec
MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
MediumLevelILCmpERec -> MediumLevelILCmpERec -> Ordering
MediumLevelILCmpERec
-> MediumLevelILCmpERec -> MediumLevelILCmpERec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Ordering
compare :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Ordering
$c< :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
< :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
$c<= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
<= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
$c> :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
> :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
$c>= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
>= :: MediumLevelILCmpERec -> MediumLevelILCmpERec -> Bool
$cmax :: MediumLevelILCmpERec
-> MediumLevelILCmpERec -> MediumLevelILCmpERec
max :: MediumLevelILCmpERec
-> MediumLevelILCmpERec -> MediumLevelILCmpERec
$cmin :: MediumLevelILCmpERec
-> MediumLevelILCmpERec -> MediumLevelILCmpERec
min :: MediumLevelILCmpERec
-> MediumLevelILCmpERec -> MediumLevelILCmpERec
Ord)

data MediumLevelILCmpSleRec = MediumLevelILCmpSleRec
  { MediumLevelILCmpSleRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSleRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSleRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpSleRec -> ShowS
[MediumLevelILCmpSleRec] -> ShowS
MediumLevelILCmpSleRec -> String
(Int -> MediumLevelILCmpSleRec -> ShowS)
-> (MediumLevelILCmpSleRec -> String)
-> ([MediumLevelILCmpSleRec] -> ShowS)
-> Show MediumLevelILCmpSleRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpSleRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpSleRec -> ShowS
$cshow :: MediumLevelILCmpSleRec -> String
show :: MediumLevelILCmpSleRec -> String
$cshowList :: [MediumLevelILCmpSleRec] -> ShowS
showList :: [MediumLevelILCmpSleRec] -> ShowS
Show, MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
(MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> (MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> Eq MediumLevelILCmpSleRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
== :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
$c/= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
/= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
Eq, Eq MediumLevelILCmpSleRec
Eq MediumLevelILCmpSleRec =>
(MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Ordering)
-> (MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> (MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> (MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> (MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool)
-> (MediumLevelILCmpSleRec
    -> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec)
-> (MediumLevelILCmpSleRec
    -> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec)
-> Ord MediumLevelILCmpSleRec
MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Ordering
MediumLevelILCmpSleRec
-> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Ordering
compare :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Ordering
$c< :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
< :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
$c<= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
<= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
$c> :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
> :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
$c>= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
>= :: MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec -> Bool
$cmax :: MediumLevelILCmpSleRec
-> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec
max :: MediumLevelILCmpSleRec
-> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec
$cmin :: MediumLevelILCmpSleRec
-> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec
min :: MediumLevelILCmpSleRec
-> MediumLevelILCmpSleRec -> MediumLevelILCmpSleRec
Ord)

data MediumLevelILCmpNeRec = MediumLevelILCmpNeRec
  { MediumLevelILCmpNeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpNeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpNeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpNeRec -> ShowS
[MediumLevelILCmpNeRec] -> ShowS
MediumLevelILCmpNeRec -> String
(Int -> MediumLevelILCmpNeRec -> ShowS)
-> (MediumLevelILCmpNeRec -> String)
-> ([MediumLevelILCmpNeRec] -> ShowS)
-> Show MediumLevelILCmpNeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpNeRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpNeRec -> ShowS
$cshow :: MediumLevelILCmpNeRec -> String
show :: MediumLevelILCmpNeRec -> String
$cshowList :: [MediumLevelILCmpNeRec] -> ShowS
showList :: [MediumLevelILCmpNeRec] -> ShowS
Show, MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
(MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> (MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> Eq MediumLevelILCmpNeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
== :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
$c/= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
/= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
Eq, Eq MediumLevelILCmpNeRec
Eq MediumLevelILCmpNeRec =>
(MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Ordering)
-> (MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> (MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> (MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> (MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool)
-> (MediumLevelILCmpNeRec
    -> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec)
-> (MediumLevelILCmpNeRec
    -> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec)
-> Ord MediumLevelILCmpNeRec
MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Ordering
MediumLevelILCmpNeRec
-> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Ordering
compare :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Ordering
$c< :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
< :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
$c<= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
<= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
$c> :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
> :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
$c>= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
>= :: MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec -> Bool
$cmax :: MediumLevelILCmpNeRec
-> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec
max :: MediumLevelILCmpNeRec
-> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec
$cmin :: MediumLevelILCmpNeRec
-> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec
min :: MediumLevelILCmpNeRec
-> MediumLevelILCmpNeRec -> MediumLevelILCmpNeRec
Ord)

data MediumLevelILCmpSltRec = MediumLevelILCmpSltRec
  { MediumLevelILCmpSltRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSltRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSltRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpSltRec -> ShowS
[MediumLevelILCmpSltRec] -> ShowS
MediumLevelILCmpSltRec -> String
(Int -> MediumLevelILCmpSltRec -> ShowS)
-> (MediumLevelILCmpSltRec -> String)
-> ([MediumLevelILCmpSltRec] -> ShowS)
-> Show MediumLevelILCmpSltRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpSltRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpSltRec -> ShowS
$cshow :: MediumLevelILCmpSltRec -> String
show :: MediumLevelILCmpSltRec -> String
$cshowList :: [MediumLevelILCmpSltRec] -> ShowS
showList :: [MediumLevelILCmpSltRec] -> ShowS
Show, MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
(MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> (MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> Eq MediumLevelILCmpSltRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
== :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
$c/= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
/= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
Eq, Eq MediumLevelILCmpSltRec
Eq MediumLevelILCmpSltRec =>
(MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Ordering)
-> (MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> (MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> (MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> (MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool)
-> (MediumLevelILCmpSltRec
    -> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec)
-> (MediumLevelILCmpSltRec
    -> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec)
-> Ord MediumLevelILCmpSltRec
MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Ordering
MediumLevelILCmpSltRec
-> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Ordering
compare :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Ordering
$c< :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
< :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
$c<= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
<= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
$c> :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
> :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
$c>= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
>= :: MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec -> Bool
$cmax :: MediumLevelILCmpSltRec
-> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec
max :: MediumLevelILCmpSltRec
-> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec
$cmin :: MediumLevelILCmpSltRec
-> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec
min :: MediumLevelILCmpSltRec
-> MediumLevelILCmpSltRec -> MediumLevelILCmpSltRec
Ord)

data MediumLevelILCmpUltRec = MediumLevelILCmpUltRec
  { MediumLevelILCmpUltRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUltRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUltRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpUltRec -> ShowS
[MediumLevelILCmpUltRec] -> ShowS
MediumLevelILCmpUltRec -> String
(Int -> MediumLevelILCmpUltRec -> ShowS)
-> (MediumLevelILCmpUltRec -> String)
-> ([MediumLevelILCmpUltRec] -> ShowS)
-> Show MediumLevelILCmpUltRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpUltRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpUltRec -> ShowS
$cshow :: MediumLevelILCmpUltRec -> String
show :: MediumLevelILCmpUltRec -> String
$cshowList :: [MediumLevelILCmpUltRec] -> ShowS
showList :: [MediumLevelILCmpUltRec] -> ShowS
Show, MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
(MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> (MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> Eq MediumLevelILCmpUltRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
== :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
$c/= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
/= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
Eq, Eq MediumLevelILCmpUltRec
Eq MediumLevelILCmpUltRec =>
(MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Ordering)
-> (MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> (MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> (MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> (MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool)
-> (MediumLevelILCmpUltRec
    -> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec)
-> (MediumLevelILCmpUltRec
    -> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec)
-> Ord MediumLevelILCmpUltRec
MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Ordering
MediumLevelILCmpUltRec
-> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Ordering
compare :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Ordering
$c< :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
< :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
$c<= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
<= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
$c> :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
> :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
$c>= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
>= :: MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec -> Bool
$cmax :: MediumLevelILCmpUltRec
-> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec
max :: MediumLevelILCmpUltRec
-> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec
$cmin :: MediumLevelILCmpUltRec
-> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec
min :: MediumLevelILCmpUltRec
-> MediumLevelILCmpUltRec -> MediumLevelILCmpUltRec
Ord)

data MediumLevelILCmpUleRec = MediumLevelILCmpUleRec
  { MediumLevelILCmpUleRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUleRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUleRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpUleRec -> ShowS
[MediumLevelILCmpUleRec] -> ShowS
MediumLevelILCmpUleRec -> String
(Int -> MediumLevelILCmpUleRec -> ShowS)
-> (MediumLevelILCmpUleRec -> String)
-> ([MediumLevelILCmpUleRec] -> ShowS)
-> Show MediumLevelILCmpUleRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpUleRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpUleRec -> ShowS
$cshow :: MediumLevelILCmpUleRec -> String
show :: MediumLevelILCmpUleRec -> String
$cshowList :: [MediumLevelILCmpUleRec] -> ShowS
showList :: [MediumLevelILCmpUleRec] -> ShowS
Show, MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
(MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> (MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> Eq MediumLevelILCmpUleRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
== :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
$c/= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
/= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
Eq, Eq MediumLevelILCmpUleRec
Eq MediumLevelILCmpUleRec =>
(MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Ordering)
-> (MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> (MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> (MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> (MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool)
-> (MediumLevelILCmpUleRec
    -> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec)
-> (MediumLevelILCmpUleRec
    -> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec)
-> Ord MediumLevelILCmpUleRec
MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Ordering
MediumLevelILCmpUleRec
-> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Ordering
compare :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Ordering
$c< :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
< :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
$c<= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
<= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
$c> :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
> :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
$c>= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
>= :: MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec -> Bool
$cmax :: MediumLevelILCmpUleRec
-> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec
max :: MediumLevelILCmpUleRec
-> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec
$cmin :: MediumLevelILCmpUleRec
-> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec
min :: MediumLevelILCmpUleRec
-> MediumLevelILCmpUleRec -> MediumLevelILCmpUleRec
Ord)

data MediumLevelILCmpSgeRec = MediumLevelILCmpSgeRec
  { MediumLevelILCmpSgeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSgeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSgeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpSgeRec -> ShowS
[MediumLevelILCmpSgeRec] -> ShowS
MediumLevelILCmpSgeRec -> String
(Int -> MediumLevelILCmpSgeRec -> ShowS)
-> (MediumLevelILCmpSgeRec -> String)
-> ([MediumLevelILCmpSgeRec] -> ShowS)
-> Show MediumLevelILCmpSgeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpSgeRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpSgeRec -> ShowS
$cshow :: MediumLevelILCmpSgeRec -> String
show :: MediumLevelILCmpSgeRec -> String
$cshowList :: [MediumLevelILCmpSgeRec] -> ShowS
showList :: [MediumLevelILCmpSgeRec] -> ShowS
Show, MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
(MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> (MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> Eq MediumLevelILCmpSgeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
== :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
$c/= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
/= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
Eq, Eq MediumLevelILCmpSgeRec
Eq MediumLevelILCmpSgeRec =>
(MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Ordering)
-> (MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> (MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> (MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> (MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool)
-> (MediumLevelILCmpSgeRec
    -> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec)
-> (MediumLevelILCmpSgeRec
    -> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec)
-> Ord MediumLevelILCmpSgeRec
MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Ordering
MediumLevelILCmpSgeRec
-> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Ordering
compare :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Ordering
$c< :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
< :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
$c<= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
<= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
$c> :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
> :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
$c>= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
>= :: MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec -> Bool
$cmax :: MediumLevelILCmpSgeRec
-> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec
max :: MediumLevelILCmpSgeRec
-> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec
$cmin :: MediumLevelILCmpSgeRec
-> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec
min :: MediumLevelILCmpSgeRec
-> MediumLevelILCmpSgeRec -> MediumLevelILCmpSgeRec
Ord)

data MediumLevelILCmpUgeRec = MediumLevelILCmpUgeRec
  { MediumLevelILCmpUgeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUgeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUgeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpUgeRec -> ShowS
[MediumLevelILCmpUgeRec] -> ShowS
MediumLevelILCmpUgeRec -> String
(Int -> MediumLevelILCmpUgeRec -> ShowS)
-> (MediumLevelILCmpUgeRec -> String)
-> ([MediumLevelILCmpUgeRec] -> ShowS)
-> Show MediumLevelILCmpUgeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpUgeRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpUgeRec -> ShowS
$cshow :: MediumLevelILCmpUgeRec -> String
show :: MediumLevelILCmpUgeRec -> String
$cshowList :: [MediumLevelILCmpUgeRec] -> ShowS
showList :: [MediumLevelILCmpUgeRec] -> ShowS
Show, MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
(MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> (MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> Eq MediumLevelILCmpUgeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
== :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
$c/= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
/= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
Eq, Eq MediumLevelILCmpUgeRec
Eq MediumLevelILCmpUgeRec =>
(MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Ordering)
-> (MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> (MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> (MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> (MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool)
-> (MediumLevelILCmpUgeRec
    -> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec)
-> (MediumLevelILCmpUgeRec
    -> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec)
-> Ord MediumLevelILCmpUgeRec
MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Ordering
MediumLevelILCmpUgeRec
-> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Ordering
compare :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Ordering
$c< :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
< :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
$c<= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
<= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
$c> :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
> :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
$c>= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
>= :: MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec -> Bool
$cmax :: MediumLevelILCmpUgeRec
-> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec
max :: MediumLevelILCmpUgeRec
-> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec
$cmin :: MediumLevelILCmpUgeRec
-> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec
min :: MediumLevelILCmpUgeRec
-> MediumLevelILCmpUgeRec -> MediumLevelILCmpUgeRec
Ord)

data MediumLevelILCmpSgtRec = MediumLevelILCmpSgtRec
  { MediumLevelILCmpSgtRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSgtRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpSgtRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpSgtRec -> ShowS
[MediumLevelILCmpSgtRec] -> ShowS
MediumLevelILCmpSgtRec -> String
(Int -> MediumLevelILCmpSgtRec -> ShowS)
-> (MediumLevelILCmpSgtRec -> String)
-> ([MediumLevelILCmpSgtRec] -> ShowS)
-> Show MediumLevelILCmpSgtRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpSgtRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpSgtRec -> ShowS
$cshow :: MediumLevelILCmpSgtRec -> String
show :: MediumLevelILCmpSgtRec -> String
$cshowList :: [MediumLevelILCmpSgtRec] -> ShowS
showList :: [MediumLevelILCmpSgtRec] -> ShowS
Show, MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
(MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> (MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> Eq MediumLevelILCmpSgtRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
== :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
$c/= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
/= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
Eq, Eq MediumLevelILCmpSgtRec
Eq MediumLevelILCmpSgtRec =>
(MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Ordering)
-> (MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> (MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> (MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> (MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool)
-> (MediumLevelILCmpSgtRec
    -> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec)
-> (MediumLevelILCmpSgtRec
    -> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec)
-> Ord MediumLevelILCmpSgtRec
MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Ordering
MediumLevelILCmpSgtRec
-> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Ordering
compare :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Ordering
$c< :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
< :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
$c<= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
<= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
$c> :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
> :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
$c>= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
>= :: MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec -> Bool
$cmax :: MediumLevelILCmpSgtRec
-> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec
max :: MediumLevelILCmpSgtRec
-> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec
$cmin :: MediumLevelILCmpSgtRec
-> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec
min :: MediumLevelILCmpSgtRec
-> MediumLevelILCmpSgtRec -> MediumLevelILCmpSgtRec
Ord)

data MediumLevelILCmpUgtRec = MediumLevelILCmpUgtRec
  { MediumLevelILCmpUgtRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUgtRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILCmpUgtRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCmpUgtRec -> ShowS
[MediumLevelILCmpUgtRec] -> ShowS
MediumLevelILCmpUgtRec -> String
(Int -> MediumLevelILCmpUgtRec -> ShowS)
-> (MediumLevelILCmpUgtRec -> String)
-> ([MediumLevelILCmpUgtRec] -> ShowS)
-> Show MediumLevelILCmpUgtRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCmpUgtRec -> ShowS
showsPrec :: Int -> MediumLevelILCmpUgtRec -> ShowS
$cshow :: MediumLevelILCmpUgtRec -> String
show :: MediumLevelILCmpUgtRec -> String
$cshowList :: [MediumLevelILCmpUgtRec] -> ShowS
showList :: [MediumLevelILCmpUgtRec] -> ShowS
Show, MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
(MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> (MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> Eq MediumLevelILCmpUgtRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
== :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
$c/= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
/= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
Eq, Eq MediumLevelILCmpUgtRec
Eq MediumLevelILCmpUgtRec =>
(MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Ordering)
-> (MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> (MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> (MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> (MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool)
-> (MediumLevelILCmpUgtRec
    -> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec)
-> (MediumLevelILCmpUgtRec
    -> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec)
-> Ord MediumLevelILCmpUgtRec
MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Ordering
MediumLevelILCmpUgtRec
-> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Ordering
compare :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Ordering
$c< :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
< :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
$c<= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
<= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
$c> :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
> :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
$c>= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
>= :: MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec -> Bool
$cmax :: MediumLevelILCmpUgtRec
-> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec
max :: MediumLevelILCmpUgtRec
-> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec
$cmin :: MediumLevelILCmpUgtRec
-> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec
min :: MediumLevelILCmpUgtRec
-> MediumLevelILCmpUgtRec -> MediumLevelILCmpUgtRec
Ord)

data MediumLevelILAndRec = MediumLevelILAndRec
  { MediumLevelILAndRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILAndRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILAndRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAndRec -> ShowS
[MediumLevelILAndRec] -> ShowS
MediumLevelILAndRec -> String
(Int -> MediumLevelILAndRec -> ShowS)
-> (MediumLevelILAndRec -> String)
-> ([MediumLevelILAndRec] -> ShowS)
-> Show MediumLevelILAndRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAndRec -> ShowS
showsPrec :: Int -> MediumLevelILAndRec -> ShowS
$cshow :: MediumLevelILAndRec -> String
show :: MediumLevelILAndRec -> String
$cshowList :: [MediumLevelILAndRec] -> ShowS
showList :: [MediumLevelILAndRec] -> ShowS
Show, MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
(MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> (MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> Eq MediumLevelILAndRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
== :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
$c/= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
/= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
Eq, Eq MediumLevelILAndRec
Eq MediumLevelILAndRec =>
(MediumLevelILAndRec -> MediumLevelILAndRec -> Ordering)
-> (MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> (MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> (MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> (MediumLevelILAndRec -> MediumLevelILAndRec -> Bool)
-> (MediumLevelILAndRec
    -> MediumLevelILAndRec -> MediumLevelILAndRec)
-> (MediumLevelILAndRec
    -> MediumLevelILAndRec -> MediumLevelILAndRec)
-> Ord MediumLevelILAndRec
MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
MediumLevelILAndRec -> MediumLevelILAndRec -> Ordering
MediumLevelILAndRec -> MediumLevelILAndRec -> MediumLevelILAndRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAndRec -> MediumLevelILAndRec -> Ordering
compare :: MediumLevelILAndRec -> MediumLevelILAndRec -> Ordering
$c< :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
< :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
$c<= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
<= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
$c> :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
> :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
$c>= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
>= :: MediumLevelILAndRec -> MediumLevelILAndRec -> Bool
$cmax :: MediumLevelILAndRec -> MediumLevelILAndRec -> MediumLevelILAndRec
max :: MediumLevelILAndRec -> MediumLevelILAndRec -> MediumLevelILAndRec
$cmin :: MediumLevelILAndRec -> MediumLevelILAndRec -> MediumLevelILAndRec
min :: MediumLevelILAndRec -> MediumLevelILAndRec -> MediumLevelILAndRec
Ord)

data MediumLevelILOrRec = MediumLevelILOrRec
  { MediumLevelILOrRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILOrRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILOrRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILOrRec -> ShowS
[MediumLevelILOrRec] -> ShowS
MediumLevelILOrRec -> String
(Int -> MediumLevelILOrRec -> ShowS)
-> (MediumLevelILOrRec -> String)
-> ([MediumLevelILOrRec] -> ShowS)
-> Show MediumLevelILOrRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILOrRec -> ShowS
showsPrec :: Int -> MediumLevelILOrRec -> ShowS
$cshow :: MediumLevelILOrRec -> String
show :: MediumLevelILOrRec -> String
$cshowList :: [MediumLevelILOrRec] -> ShowS
showList :: [MediumLevelILOrRec] -> ShowS
Show, MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
(MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> Eq MediumLevelILOrRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
== :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
$c/= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
/= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
Eq, Eq MediumLevelILOrRec
Eq MediumLevelILOrRec =>
(MediumLevelILOrRec -> MediumLevelILOrRec -> Ordering)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> Bool)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec)
-> (MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec)
-> Ord MediumLevelILOrRec
MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
MediumLevelILOrRec -> MediumLevelILOrRec -> Ordering
MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILOrRec -> MediumLevelILOrRec -> Ordering
compare :: MediumLevelILOrRec -> MediumLevelILOrRec -> Ordering
$c< :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
< :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
$c<= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
<= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
$c> :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
> :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
$c>= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
>= :: MediumLevelILOrRec -> MediumLevelILOrRec -> Bool
$cmax :: MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec
max :: MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec
$cmin :: MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec
min :: MediumLevelILOrRec -> MediumLevelILOrRec -> MediumLevelILOrRec
Ord)

data MediumLevelILXorRec = MediumLevelILXorRec
  { MediumLevelILXorRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILXorRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILXorRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILXorRec -> ShowS
[MediumLevelILXorRec] -> ShowS
MediumLevelILXorRec -> String
(Int -> MediumLevelILXorRec -> ShowS)
-> (MediumLevelILXorRec -> String)
-> ([MediumLevelILXorRec] -> ShowS)
-> Show MediumLevelILXorRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILXorRec -> ShowS
showsPrec :: Int -> MediumLevelILXorRec -> ShowS
$cshow :: MediumLevelILXorRec -> String
show :: MediumLevelILXorRec -> String
$cshowList :: [MediumLevelILXorRec] -> ShowS
showList :: [MediumLevelILXorRec] -> ShowS
Show, MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
(MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> (MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> Eq MediumLevelILXorRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
== :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
$c/= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
/= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
Eq, Eq MediumLevelILXorRec
Eq MediumLevelILXorRec =>
(MediumLevelILXorRec -> MediumLevelILXorRec -> Ordering)
-> (MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> (MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> (MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> (MediumLevelILXorRec -> MediumLevelILXorRec -> Bool)
-> (MediumLevelILXorRec
    -> MediumLevelILXorRec -> MediumLevelILXorRec)
-> (MediumLevelILXorRec
    -> MediumLevelILXorRec -> MediumLevelILXorRec)
-> Ord MediumLevelILXorRec
MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
MediumLevelILXorRec -> MediumLevelILXorRec -> Ordering
MediumLevelILXorRec -> MediumLevelILXorRec -> MediumLevelILXorRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILXorRec -> MediumLevelILXorRec -> Ordering
compare :: MediumLevelILXorRec -> MediumLevelILXorRec -> Ordering
$c< :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
< :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
$c<= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
<= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
$c> :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
> :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
$c>= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
>= :: MediumLevelILXorRec -> MediumLevelILXorRec -> Bool
$cmax :: MediumLevelILXorRec -> MediumLevelILXorRec -> MediumLevelILXorRec
max :: MediumLevelILXorRec -> MediumLevelILXorRec -> MediumLevelILXorRec
$cmin :: MediumLevelILXorRec -> MediumLevelILXorRec -> MediumLevelILXorRec
min :: MediumLevelILXorRec -> MediumLevelILXorRec -> MediumLevelILXorRec
Ord)

data MediumLevelILLslRec = MediumLevelILLslRec
  { MediumLevelILLslRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILLslRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILLslRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLslRec -> ShowS
[MediumLevelILLslRec] -> ShowS
MediumLevelILLslRec -> String
(Int -> MediumLevelILLslRec -> ShowS)
-> (MediumLevelILLslRec -> String)
-> ([MediumLevelILLslRec] -> ShowS)
-> Show MediumLevelILLslRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLslRec -> ShowS
showsPrec :: Int -> MediumLevelILLslRec -> ShowS
$cshow :: MediumLevelILLslRec -> String
show :: MediumLevelILLslRec -> String
$cshowList :: [MediumLevelILLslRec] -> ShowS
showList :: [MediumLevelILLslRec] -> ShowS
Show, MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
(MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> (MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> Eq MediumLevelILLslRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
== :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
$c/= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
/= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
Eq, Eq MediumLevelILLslRec
Eq MediumLevelILLslRec =>
(MediumLevelILLslRec -> MediumLevelILLslRec -> Ordering)
-> (MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> (MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> (MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> (MediumLevelILLslRec -> MediumLevelILLslRec -> Bool)
-> (MediumLevelILLslRec
    -> MediumLevelILLslRec -> MediumLevelILLslRec)
-> (MediumLevelILLslRec
    -> MediumLevelILLslRec -> MediumLevelILLslRec)
-> Ord MediumLevelILLslRec
MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
MediumLevelILLslRec -> MediumLevelILLslRec -> Ordering
MediumLevelILLslRec -> MediumLevelILLslRec -> MediumLevelILLslRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLslRec -> MediumLevelILLslRec -> Ordering
compare :: MediumLevelILLslRec -> MediumLevelILLslRec -> Ordering
$c< :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
< :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
$c<= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
<= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
$c> :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
> :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
$c>= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
>= :: MediumLevelILLslRec -> MediumLevelILLslRec -> Bool
$cmax :: MediumLevelILLslRec -> MediumLevelILLslRec -> MediumLevelILLslRec
max :: MediumLevelILLslRec -> MediumLevelILLslRec -> MediumLevelILLslRec
$cmin :: MediumLevelILLslRec -> MediumLevelILLslRec -> MediumLevelILLslRec
min :: MediumLevelILLslRec -> MediumLevelILLslRec -> MediumLevelILLslRec
Ord)

data MediumLevelILLsrRec = MediumLevelILLsrRec
  { MediumLevelILLsrRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILLsrRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILLsrRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLsrRec -> ShowS
[MediumLevelILLsrRec] -> ShowS
MediumLevelILLsrRec -> String
(Int -> MediumLevelILLsrRec -> ShowS)
-> (MediumLevelILLsrRec -> String)
-> ([MediumLevelILLsrRec] -> ShowS)
-> Show MediumLevelILLsrRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLsrRec -> ShowS
showsPrec :: Int -> MediumLevelILLsrRec -> ShowS
$cshow :: MediumLevelILLsrRec -> String
show :: MediumLevelILLsrRec -> String
$cshowList :: [MediumLevelILLsrRec] -> ShowS
showList :: [MediumLevelILLsrRec] -> ShowS
Show, MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
(MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> (MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> Eq MediumLevelILLsrRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
== :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
$c/= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
/= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
Eq, Eq MediumLevelILLsrRec
Eq MediumLevelILLsrRec =>
(MediumLevelILLsrRec -> MediumLevelILLsrRec -> Ordering)
-> (MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> (MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> (MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> (MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool)
-> (MediumLevelILLsrRec
    -> MediumLevelILLsrRec -> MediumLevelILLsrRec)
-> (MediumLevelILLsrRec
    -> MediumLevelILLsrRec -> MediumLevelILLsrRec)
-> Ord MediumLevelILLsrRec
MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
MediumLevelILLsrRec -> MediumLevelILLsrRec -> Ordering
MediumLevelILLsrRec -> MediumLevelILLsrRec -> MediumLevelILLsrRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Ordering
compare :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Ordering
$c< :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
< :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
$c<= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
<= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
$c> :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
> :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
$c>= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
>= :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> Bool
$cmax :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> MediumLevelILLsrRec
max :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> MediumLevelILLsrRec
$cmin :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> MediumLevelILLsrRec
min :: MediumLevelILLsrRec -> MediumLevelILLsrRec -> MediumLevelILLsrRec
Ord)

data MediumLevelILAsrRec = MediumLevelILAsrRec
  { MediumLevelILAsrRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILAsrRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILAsrRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAsrRec -> ShowS
[MediumLevelILAsrRec] -> ShowS
MediumLevelILAsrRec -> String
(Int -> MediumLevelILAsrRec -> ShowS)
-> (MediumLevelILAsrRec -> String)
-> ([MediumLevelILAsrRec] -> ShowS)
-> Show MediumLevelILAsrRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAsrRec -> ShowS
showsPrec :: Int -> MediumLevelILAsrRec -> ShowS
$cshow :: MediumLevelILAsrRec -> String
show :: MediumLevelILAsrRec -> String
$cshowList :: [MediumLevelILAsrRec] -> ShowS
showList :: [MediumLevelILAsrRec] -> ShowS
Show, MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
(MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> (MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> Eq MediumLevelILAsrRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
== :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
$c/= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
/= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
Eq, Eq MediumLevelILAsrRec
Eq MediumLevelILAsrRec =>
(MediumLevelILAsrRec -> MediumLevelILAsrRec -> Ordering)
-> (MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> (MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> (MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> (MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool)
-> (MediumLevelILAsrRec
    -> MediumLevelILAsrRec -> MediumLevelILAsrRec)
-> (MediumLevelILAsrRec
    -> MediumLevelILAsrRec -> MediumLevelILAsrRec)
-> Ord MediumLevelILAsrRec
MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
MediumLevelILAsrRec -> MediumLevelILAsrRec -> Ordering
MediumLevelILAsrRec -> MediumLevelILAsrRec -> MediumLevelILAsrRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Ordering
compare :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Ordering
$c< :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
< :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
$c<= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
<= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
$c> :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
> :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
$c>= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
>= :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> Bool
$cmax :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> MediumLevelILAsrRec
max :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> MediumLevelILAsrRec
$cmin :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> MediumLevelILAsrRec
min :: MediumLevelILAsrRec -> MediumLevelILAsrRec -> MediumLevelILAsrRec
Ord)

data MediumLevelILRolRec = MediumLevelILRolRec
  { MediumLevelILRolRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILRolRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILRolRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRolRec -> ShowS
[MediumLevelILRolRec] -> ShowS
MediumLevelILRolRec -> String
(Int -> MediumLevelILRolRec -> ShowS)
-> (MediumLevelILRolRec -> String)
-> ([MediumLevelILRolRec] -> ShowS)
-> Show MediumLevelILRolRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRolRec -> ShowS
showsPrec :: Int -> MediumLevelILRolRec -> ShowS
$cshow :: MediumLevelILRolRec -> String
show :: MediumLevelILRolRec -> String
$cshowList :: [MediumLevelILRolRec] -> ShowS
showList :: [MediumLevelILRolRec] -> ShowS
Show, MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
(MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> (MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> Eq MediumLevelILRolRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
== :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
$c/= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
/= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
Eq, Eq MediumLevelILRolRec
Eq MediumLevelILRolRec =>
(MediumLevelILRolRec -> MediumLevelILRolRec -> Ordering)
-> (MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> (MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> (MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> (MediumLevelILRolRec -> MediumLevelILRolRec -> Bool)
-> (MediumLevelILRolRec
    -> MediumLevelILRolRec -> MediumLevelILRolRec)
-> (MediumLevelILRolRec
    -> MediumLevelILRolRec -> MediumLevelILRolRec)
-> Ord MediumLevelILRolRec
MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
MediumLevelILRolRec -> MediumLevelILRolRec -> Ordering
MediumLevelILRolRec -> MediumLevelILRolRec -> MediumLevelILRolRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRolRec -> MediumLevelILRolRec -> Ordering
compare :: MediumLevelILRolRec -> MediumLevelILRolRec -> Ordering
$c< :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
< :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
$c<= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
<= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
$c> :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
> :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
$c>= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
>= :: MediumLevelILRolRec -> MediumLevelILRolRec -> Bool
$cmax :: MediumLevelILRolRec -> MediumLevelILRolRec -> MediumLevelILRolRec
max :: MediumLevelILRolRec -> MediumLevelILRolRec -> MediumLevelILRolRec
$cmin :: MediumLevelILRolRec -> MediumLevelILRolRec -> MediumLevelILRolRec
min :: MediumLevelILRolRec -> MediumLevelILRolRec -> MediumLevelILRolRec
Ord)

data MediumLevelILRorRec = MediumLevelILRorRec
  { MediumLevelILRorRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILRorRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILRorRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRorRec -> ShowS
[MediumLevelILRorRec] -> ShowS
MediumLevelILRorRec -> String
(Int -> MediumLevelILRorRec -> ShowS)
-> (MediumLevelILRorRec -> String)
-> ([MediumLevelILRorRec] -> ShowS)
-> Show MediumLevelILRorRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRorRec -> ShowS
showsPrec :: Int -> MediumLevelILRorRec -> ShowS
$cshow :: MediumLevelILRorRec -> String
show :: MediumLevelILRorRec -> String
$cshowList :: [MediumLevelILRorRec] -> ShowS
showList :: [MediumLevelILRorRec] -> ShowS
Show, MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
(MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> (MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> Eq MediumLevelILRorRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
== :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
$c/= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
/= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
Eq, Eq MediumLevelILRorRec
Eq MediumLevelILRorRec =>
(MediumLevelILRorRec -> MediumLevelILRorRec -> Ordering)
-> (MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> (MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> (MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> (MediumLevelILRorRec -> MediumLevelILRorRec -> Bool)
-> (MediumLevelILRorRec
    -> MediumLevelILRorRec -> MediumLevelILRorRec)
-> (MediumLevelILRorRec
    -> MediumLevelILRorRec -> MediumLevelILRorRec)
-> Ord MediumLevelILRorRec
MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
MediumLevelILRorRec -> MediumLevelILRorRec -> Ordering
MediumLevelILRorRec -> MediumLevelILRorRec -> MediumLevelILRorRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRorRec -> MediumLevelILRorRec -> Ordering
compare :: MediumLevelILRorRec -> MediumLevelILRorRec -> Ordering
$c< :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
< :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
$c<= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
<= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
$c> :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
> :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
$c>= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
>= :: MediumLevelILRorRec -> MediumLevelILRorRec -> Bool
$cmax :: MediumLevelILRorRec -> MediumLevelILRorRec -> MediumLevelILRorRec
max :: MediumLevelILRorRec -> MediumLevelILRorRec -> MediumLevelILRorRec
$cmin :: MediumLevelILRorRec -> MediumLevelILRorRec -> MediumLevelILRorRec
min :: MediumLevelILRorRec -> MediumLevelILRorRec -> MediumLevelILRorRec
Ord)

data MediumLevelILMulRec = MediumLevelILMulRec
  { MediumLevelILMulRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMulRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMulRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMulRec -> ShowS
[MediumLevelILMulRec] -> ShowS
MediumLevelILMulRec -> String
(Int -> MediumLevelILMulRec -> ShowS)
-> (MediumLevelILMulRec -> String)
-> ([MediumLevelILMulRec] -> ShowS)
-> Show MediumLevelILMulRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMulRec -> ShowS
showsPrec :: Int -> MediumLevelILMulRec -> ShowS
$cshow :: MediumLevelILMulRec -> String
show :: MediumLevelILMulRec -> String
$cshowList :: [MediumLevelILMulRec] -> ShowS
showList :: [MediumLevelILMulRec] -> ShowS
Show, MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
(MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> (MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> Eq MediumLevelILMulRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
== :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
$c/= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
/= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
Eq, Eq MediumLevelILMulRec
Eq MediumLevelILMulRec =>
(MediumLevelILMulRec -> MediumLevelILMulRec -> Ordering)
-> (MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> (MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> (MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> (MediumLevelILMulRec -> MediumLevelILMulRec -> Bool)
-> (MediumLevelILMulRec
    -> MediumLevelILMulRec -> MediumLevelILMulRec)
-> (MediumLevelILMulRec
    -> MediumLevelILMulRec -> MediumLevelILMulRec)
-> Ord MediumLevelILMulRec
MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
MediumLevelILMulRec -> MediumLevelILMulRec -> Ordering
MediumLevelILMulRec -> MediumLevelILMulRec -> MediumLevelILMulRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMulRec -> MediumLevelILMulRec -> Ordering
compare :: MediumLevelILMulRec -> MediumLevelILMulRec -> Ordering
$c< :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
< :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
$c<= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
<= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
$c> :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
> :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
$c>= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
>= :: MediumLevelILMulRec -> MediumLevelILMulRec -> Bool
$cmax :: MediumLevelILMulRec -> MediumLevelILMulRec -> MediumLevelILMulRec
max :: MediumLevelILMulRec -> MediumLevelILMulRec -> MediumLevelILMulRec
$cmin :: MediumLevelILMulRec -> MediumLevelILMulRec -> MediumLevelILMulRec
min :: MediumLevelILMulRec -> MediumLevelILMulRec -> MediumLevelILMulRec
Ord)

data MediumLevelILMuluRec = MediumLevelILMuluRec
  { MediumLevelILMuluRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMuluRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMuluRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMuluRec -> ShowS
[MediumLevelILMuluRec] -> ShowS
MediumLevelILMuluRec -> String
(Int -> MediumLevelILMuluRec -> ShowS)
-> (MediumLevelILMuluRec -> String)
-> ([MediumLevelILMuluRec] -> ShowS)
-> Show MediumLevelILMuluRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMuluRec -> ShowS
showsPrec :: Int -> MediumLevelILMuluRec -> ShowS
$cshow :: MediumLevelILMuluRec -> String
show :: MediumLevelILMuluRec -> String
$cshowList :: [MediumLevelILMuluRec] -> ShowS
showList :: [MediumLevelILMuluRec] -> ShowS
Show, MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
(MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> (MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> Eq MediumLevelILMuluRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
== :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
$c/= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
/= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
Eq, Eq MediumLevelILMuluRec
Eq MediumLevelILMuluRec =>
(MediumLevelILMuluRec -> MediumLevelILMuluRec -> Ordering)
-> (MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> (MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> (MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> (MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool)
-> (MediumLevelILMuluRec
    -> MediumLevelILMuluRec -> MediumLevelILMuluRec)
-> (MediumLevelILMuluRec
    -> MediumLevelILMuluRec -> MediumLevelILMuluRec)
-> Ord MediumLevelILMuluRec
MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
MediumLevelILMuluRec -> MediumLevelILMuluRec -> Ordering
MediumLevelILMuluRec
-> MediumLevelILMuluRec -> MediumLevelILMuluRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Ordering
compare :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Ordering
$c< :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
< :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
$c<= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
<= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
$c> :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
> :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
$c>= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
>= :: MediumLevelILMuluRec -> MediumLevelILMuluRec -> Bool
$cmax :: MediumLevelILMuluRec
-> MediumLevelILMuluRec -> MediumLevelILMuluRec
max :: MediumLevelILMuluRec
-> MediumLevelILMuluRec -> MediumLevelILMuluRec
$cmin :: MediumLevelILMuluRec
-> MediumLevelILMuluRec -> MediumLevelILMuluRec
min :: MediumLevelILMuluRec
-> MediumLevelILMuluRec -> MediumLevelILMuluRec
Ord)

data MediumLevelILMuluDpRec = MediumLevelILMuluDpRec
  { MediumLevelILMuluDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMuluDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMuluDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMuluDpRec -> ShowS
[MediumLevelILMuluDpRec] -> ShowS
MediumLevelILMuluDpRec -> String
(Int -> MediumLevelILMuluDpRec -> ShowS)
-> (MediumLevelILMuluDpRec -> String)
-> ([MediumLevelILMuluDpRec] -> ShowS)
-> Show MediumLevelILMuluDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMuluDpRec -> ShowS
showsPrec :: Int -> MediumLevelILMuluDpRec -> ShowS
$cshow :: MediumLevelILMuluDpRec -> String
show :: MediumLevelILMuluDpRec -> String
$cshowList :: [MediumLevelILMuluDpRec] -> ShowS
showList :: [MediumLevelILMuluDpRec] -> ShowS
Show, MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
(MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> (MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> Eq MediumLevelILMuluDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
== :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
$c/= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
/= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
Eq, Eq MediumLevelILMuluDpRec
Eq MediumLevelILMuluDpRec =>
(MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Ordering)
-> (MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> (MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> (MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> (MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool)
-> (MediumLevelILMuluDpRec
    -> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec)
-> (MediumLevelILMuluDpRec
    -> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec)
-> Ord MediumLevelILMuluDpRec
MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Ordering
MediumLevelILMuluDpRec
-> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Ordering
compare :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Ordering
$c< :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
< :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
$c<= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
<= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
$c> :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
> :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
$c>= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
>= :: MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec -> Bool
$cmax :: MediumLevelILMuluDpRec
-> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec
max :: MediumLevelILMuluDpRec
-> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec
$cmin :: MediumLevelILMuluDpRec
-> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec
min :: MediumLevelILMuluDpRec
-> MediumLevelILMuluDpRec -> MediumLevelILMuluDpRec
Ord)

data MediumLevelILMulsDpRec = MediumLevelILMulsDpRec
  { MediumLevelILMulsDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMulsDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMulsDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMulsDpRec -> ShowS
[MediumLevelILMulsDpRec] -> ShowS
MediumLevelILMulsDpRec -> String
(Int -> MediumLevelILMulsDpRec -> ShowS)
-> (MediumLevelILMulsDpRec -> String)
-> ([MediumLevelILMulsDpRec] -> ShowS)
-> Show MediumLevelILMulsDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMulsDpRec -> ShowS
showsPrec :: Int -> MediumLevelILMulsDpRec -> ShowS
$cshow :: MediumLevelILMulsDpRec -> String
show :: MediumLevelILMulsDpRec -> String
$cshowList :: [MediumLevelILMulsDpRec] -> ShowS
showList :: [MediumLevelILMulsDpRec] -> ShowS
Show, MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
(MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> (MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> Eq MediumLevelILMulsDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
== :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
$c/= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
/= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
Eq, Eq MediumLevelILMulsDpRec
Eq MediumLevelILMulsDpRec =>
(MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Ordering)
-> (MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> (MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> (MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> (MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool)
-> (MediumLevelILMulsDpRec
    -> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec)
-> (MediumLevelILMulsDpRec
    -> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec)
-> Ord MediumLevelILMulsDpRec
MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Ordering
MediumLevelILMulsDpRec
-> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Ordering
compare :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Ordering
$c< :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
< :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
$c<= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
<= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
$c> :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
> :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
$c>= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
>= :: MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec -> Bool
$cmax :: MediumLevelILMulsDpRec
-> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec
max :: MediumLevelILMulsDpRec
-> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec
$cmin :: MediumLevelILMulsDpRec
-> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec
min :: MediumLevelILMulsDpRec
-> MediumLevelILMulsDpRec -> MediumLevelILMulsDpRec
Ord)

data MediumLevelILDivsRec = MediumLevelILDivsRec
  { MediumLevelILDivsRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILDivsRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILDivsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILDivsRec -> ShowS
[MediumLevelILDivsRec] -> ShowS
MediumLevelILDivsRec -> String
(Int -> MediumLevelILDivsRec -> ShowS)
-> (MediumLevelILDivsRec -> String)
-> ([MediumLevelILDivsRec] -> ShowS)
-> Show MediumLevelILDivsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILDivsRec -> ShowS
showsPrec :: Int -> MediumLevelILDivsRec -> ShowS
$cshow :: MediumLevelILDivsRec -> String
show :: MediumLevelILDivsRec -> String
$cshowList :: [MediumLevelILDivsRec] -> ShowS
showList :: [MediumLevelILDivsRec] -> ShowS
Show, MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
(MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> (MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> Eq MediumLevelILDivsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
== :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
$c/= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
/= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
Eq, Eq MediumLevelILDivsRec
Eq MediumLevelILDivsRec =>
(MediumLevelILDivsRec -> MediumLevelILDivsRec -> Ordering)
-> (MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> (MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> (MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> (MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool)
-> (MediumLevelILDivsRec
    -> MediumLevelILDivsRec -> MediumLevelILDivsRec)
-> (MediumLevelILDivsRec
    -> MediumLevelILDivsRec -> MediumLevelILDivsRec)
-> Ord MediumLevelILDivsRec
MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
MediumLevelILDivsRec -> MediumLevelILDivsRec -> Ordering
MediumLevelILDivsRec
-> MediumLevelILDivsRec -> MediumLevelILDivsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Ordering
compare :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Ordering
$c< :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
< :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
$c<= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
<= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
$c> :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
> :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
$c>= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
>= :: MediumLevelILDivsRec -> MediumLevelILDivsRec -> Bool
$cmax :: MediumLevelILDivsRec
-> MediumLevelILDivsRec -> MediumLevelILDivsRec
max :: MediumLevelILDivsRec
-> MediumLevelILDivsRec -> MediumLevelILDivsRec
$cmin :: MediumLevelILDivsRec
-> MediumLevelILDivsRec -> MediumLevelILDivsRec
min :: MediumLevelILDivsRec
-> MediumLevelILDivsRec -> MediumLevelILDivsRec
Ord)

data MediumLevelILDivuRec = MediumLevelILDivuRec
  { MediumLevelILDivuRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILDivuRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILDivuRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILDivuRec -> ShowS
[MediumLevelILDivuRec] -> ShowS
MediumLevelILDivuRec -> String
(Int -> MediumLevelILDivuRec -> ShowS)
-> (MediumLevelILDivuRec -> String)
-> ([MediumLevelILDivuRec] -> ShowS)
-> Show MediumLevelILDivuRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILDivuRec -> ShowS
showsPrec :: Int -> MediumLevelILDivuRec -> ShowS
$cshow :: MediumLevelILDivuRec -> String
show :: MediumLevelILDivuRec -> String
$cshowList :: [MediumLevelILDivuRec] -> ShowS
showList :: [MediumLevelILDivuRec] -> ShowS
Show, MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
(MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> (MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> Eq MediumLevelILDivuRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
== :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
$c/= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
/= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
Eq, Eq MediumLevelILDivuRec
Eq MediumLevelILDivuRec =>
(MediumLevelILDivuRec -> MediumLevelILDivuRec -> Ordering)
-> (MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> (MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> (MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> (MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool)
-> (MediumLevelILDivuRec
    -> MediumLevelILDivuRec -> MediumLevelILDivuRec)
-> (MediumLevelILDivuRec
    -> MediumLevelILDivuRec -> MediumLevelILDivuRec)
-> Ord MediumLevelILDivuRec
MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
MediumLevelILDivuRec -> MediumLevelILDivuRec -> Ordering
MediumLevelILDivuRec
-> MediumLevelILDivuRec -> MediumLevelILDivuRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Ordering
compare :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Ordering
$c< :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
< :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
$c<= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
<= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
$c> :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
> :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
$c>= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
>= :: MediumLevelILDivuRec -> MediumLevelILDivuRec -> Bool
$cmax :: MediumLevelILDivuRec
-> MediumLevelILDivuRec -> MediumLevelILDivuRec
max :: MediumLevelILDivuRec
-> MediumLevelILDivuRec -> MediumLevelILDivuRec
$cmin :: MediumLevelILDivuRec
-> MediumLevelILDivuRec -> MediumLevelILDivuRec
min :: MediumLevelILDivuRec
-> MediumLevelILDivuRec -> MediumLevelILDivuRec
Ord)

data MediumLevelILDivuDpRec = MediumLevelILDivuDpRec
  { MediumLevelILDivuDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILDivuDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILDivuDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILDivuDpRec -> ShowS
[MediumLevelILDivuDpRec] -> ShowS
MediumLevelILDivuDpRec -> String
(Int -> MediumLevelILDivuDpRec -> ShowS)
-> (MediumLevelILDivuDpRec -> String)
-> ([MediumLevelILDivuDpRec] -> ShowS)
-> Show MediumLevelILDivuDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILDivuDpRec -> ShowS
showsPrec :: Int -> MediumLevelILDivuDpRec -> ShowS
$cshow :: MediumLevelILDivuDpRec -> String
show :: MediumLevelILDivuDpRec -> String
$cshowList :: [MediumLevelILDivuDpRec] -> ShowS
showList :: [MediumLevelILDivuDpRec] -> ShowS
Show, MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
(MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> (MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> Eq MediumLevelILDivuDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
== :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
$c/= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
/= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
Eq, Eq MediumLevelILDivuDpRec
Eq MediumLevelILDivuDpRec =>
(MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Ordering)
-> (MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> (MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> (MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> (MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool)
-> (MediumLevelILDivuDpRec
    -> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec)
-> (MediumLevelILDivuDpRec
    -> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec)
-> Ord MediumLevelILDivuDpRec
MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Ordering
MediumLevelILDivuDpRec
-> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Ordering
compare :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Ordering
$c< :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
< :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
$c<= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
<= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
$c> :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
> :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
$c>= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
>= :: MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec -> Bool
$cmax :: MediumLevelILDivuDpRec
-> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec
max :: MediumLevelILDivuDpRec
-> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec
$cmin :: MediumLevelILDivuDpRec
-> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec
min :: MediumLevelILDivuDpRec
-> MediumLevelILDivuDpRec -> MediumLevelILDivuDpRec
Ord)

data MediumLevelILDivsDpRec = MediumLevelILDivsDpRec
  { MediumLevelILDivsDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILDivsDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILDivsDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILDivsDpRec -> ShowS
[MediumLevelILDivsDpRec] -> ShowS
MediumLevelILDivsDpRec -> String
(Int -> MediumLevelILDivsDpRec -> ShowS)
-> (MediumLevelILDivsDpRec -> String)
-> ([MediumLevelILDivsDpRec] -> ShowS)
-> Show MediumLevelILDivsDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILDivsDpRec -> ShowS
showsPrec :: Int -> MediumLevelILDivsDpRec -> ShowS
$cshow :: MediumLevelILDivsDpRec -> String
show :: MediumLevelILDivsDpRec -> String
$cshowList :: [MediumLevelILDivsDpRec] -> ShowS
showList :: [MediumLevelILDivsDpRec] -> ShowS
Show, MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
(MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> (MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> Eq MediumLevelILDivsDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
== :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
$c/= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
/= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
Eq, Eq MediumLevelILDivsDpRec
Eq MediumLevelILDivsDpRec =>
(MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Ordering)
-> (MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> (MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> (MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> (MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool)
-> (MediumLevelILDivsDpRec
    -> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec)
-> (MediumLevelILDivsDpRec
    -> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec)
-> Ord MediumLevelILDivsDpRec
MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Ordering
MediumLevelILDivsDpRec
-> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Ordering
compare :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Ordering
$c< :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
< :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
$c<= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
<= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
$c> :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
> :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
$c>= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
>= :: MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec -> Bool
$cmax :: MediumLevelILDivsDpRec
-> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec
max :: MediumLevelILDivsDpRec
-> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec
$cmin :: MediumLevelILDivsDpRec
-> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec
min :: MediumLevelILDivsDpRec
-> MediumLevelILDivsDpRec -> MediumLevelILDivsDpRec
Ord)

data MediumLevelILModuRec = MediumLevelILModuRec
  { MediumLevelILModuRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILModuRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILModuRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILModuRec -> ShowS
[MediumLevelILModuRec] -> ShowS
MediumLevelILModuRec -> String
(Int -> MediumLevelILModuRec -> ShowS)
-> (MediumLevelILModuRec -> String)
-> ([MediumLevelILModuRec] -> ShowS)
-> Show MediumLevelILModuRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILModuRec -> ShowS
showsPrec :: Int -> MediumLevelILModuRec -> ShowS
$cshow :: MediumLevelILModuRec -> String
show :: MediumLevelILModuRec -> String
$cshowList :: [MediumLevelILModuRec] -> ShowS
showList :: [MediumLevelILModuRec] -> ShowS
Show, MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
(MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> (MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> Eq MediumLevelILModuRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
== :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
$c/= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
/= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
Eq, Eq MediumLevelILModuRec
Eq MediumLevelILModuRec =>
(MediumLevelILModuRec -> MediumLevelILModuRec -> Ordering)
-> (MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> (MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> (MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> (MediumLevelILModuRec -> MediumLevelILModuRec -> Bool)
-> (MediumLevelILModuRec
    -> MediumLevelILModuRec -> MediumLevelILModuRec)
-> (MediumLevelILModuRec
    -> MediumLevelILModuRec -> MediumLevelILModuRec)
-> Ord MediumLevelILModuRec
MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
MediumLevelILModuRec -> MediumLevelILModuRec -> Ordering
MediumLevelILModuRec
-> MediumLevelILModuRec -> MediumLevelILModuRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILModuRec -> MediumLevelILModuRec -> Ordering
compare :: MediumLevelILModuRec -> MediumLevelILModuRec -> Ordering
$c< :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
< :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
$c<= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
<= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
$c> :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
> :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
$c>= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
>= :: MediumLevelILModuRec -> MediumLevelILModuRec -> Bool
$cmax :: MediumLevelILModuRec
-> MediumLevelILModuRec -> MediumLevelILModuRec
max :: MediumLevelILModuRec
-> MediumLevelILModuRec -> MediumLevelILModuRec
$cmin :: MediumLevelILModuRec
-> MediumLevelILModuRec -> MediumLevelILModuRec
min :: MediumLevelILModuRec
-> MediumLevelILModuRec -> MediumLevelILModuRec
Ord)

data MediumLevelILModuDpRec = MediumLevelILModuDpRec
  { MediumLevelILModuDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILModuDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILModuDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILModuDpRec -> ShowS
[MediumLevelILModuDpRec] -> ShowS
MediumLevelILModuDpRec -> String
(Int -> MediumLevelILModuDpRec -> ShowS)
-> (MediumLevelILModuDpRec -> String)
-> ([MediumLevelILModuDpRec] -> ShowS)
-> Show MediumLevelILModuDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILModuDpRec -> ShowS
showsPrec :: Int -> MediumLevelILModuDpRec -> ShowS
$cshow :: MediumLevelILModuDpRec -> String
show :: MediumLevelILModuDpRec -> String
$cshowList :: [MediumLevelILModuDpRec] -> ShowS
showList :: [MediumLevelILModuDpRec] -> ShowS
Show, MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
(MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> (MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> Eq MediumLevelILModuDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
== :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
$c/= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
/= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
Eq, Eq MediumLevelILModuDpRec
Eq MediumLevelILModuDpRec =>
(MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Ordering)
-> (MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> (MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> (MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> (MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool)
-> (MediumLevelILModuDpRec
    -> MediumLevelILModuDpRec -> MediumLevelILModuDpRec)
-> (MediumLevelILModuDpRec
    -> MediumLevelILModuDpRec -> MediumLevelILModuDpRec)
-> Ord MediumLevelILModuDpRec
MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Ordering
MediumLevelILModuDpRec
-> MediumLevelILModuDpRec -> MediumLevelILModuDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Ordering
compare :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Ordering
$c< :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
< :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
$c<= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
<= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
$c> :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
> :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
$c>= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
>= :: MediumLevelILModuDpRec -> MediumLevelILModuDpRec -> Bool
$cmax :: MediumLevelILModuDpRec
-> MediumLevelILModuDpRec -> MediumLevelILModuDpRec
max :: MediumLevelILModuDpRec
-> MediumLevelILModuDpRec -> MediumLevelILModuDpRec
$cmin :: MediumLevelILModuDpRec
-> MediumLevelILModuDpRec -> MediumLevelILModuDpRec
min :: MediumLevelILModuDpRec
-> MediumLevelILModuDpRec -> MediumLevelILModuDpRec
Ord)

data MediumLevelILModsRec = MediumLevelILModsRec
  { MediumLevelILModsRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILModsRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILModsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILModsRec -> ShowS
[MediumLevelILModsRec] -> ShowS
MediumLevelILModsRec -> String
(Int -> MediumLevelILModsRec -> ShowS)
-> (MediumLevelILModsRec -> String)
-> ([MediumLevelILModsRec] -> ShowS)
-> Show MediumLevelILModsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILModsRec -> ShowS
showsPrec :: Int -> MediumLevelILModsRec -> ShowS
$cshow :: MediumLevelILModsRec -> String
show :: MediumLevelILModsRec -> String
$cshowList :: [MediumLevelILModsRec] -> ShowS
showList :: [MediumLevelILModsRec] -> ShowS
Show, MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
(MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> (MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> Eq MediumLevelILModsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
== :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
$c/= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
/= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
Eq, Eq MediumLevelILModsRec
Eq MediumLevelILModsRec =>
(MediumLevelILModsRec -> MediumLevelILModsRec -> Ordering)
-> (MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> (MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> (MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> (MediumLevelILModsRec -> MediumLevelILModsRec -> Bool)
-> (MediumLevelILModsRec
    -> MediumLevelILModsRec -> MediumLevelILModsRec)
-> (MediumLevelILModsRec
    -> MediumLevelILModsRec -> MediumLevelILModsRec)
-> Ord MediumLevelILModsRec
MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
MediumLevelILModsRec -> MediumLevelILModsRec -> Ordering
MediumLevelILModsRec
-> MediumLevelILModsRec -> MediumLevelILModsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILModsRec -> MediumLevelILModsRec -> Ordering
compare :: MediumLevelILModsRec -> MediumLevelILModsRec -> Ordering
$c< :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
< :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
$c<= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
<= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
$c> :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
> :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
$c>= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
>= :: MediumLevelILModsRec -> MediumLevelILModsRec -> Bool
$cmax :: MediumLevelILModsRec
-> MediumLevelILModsRec -> MediumLevelILModsRec
max :: MediumLevelILModsRec
-> MediumLevelILModsRec -> MediumLevelILModsRec
$cmin :: MediumLevelILModsRec
-> MediumLevelILModsRec -> MediumLevelILModsRec
min :: MediumLevelILModsRec
-> MediumLevelILModsRec -> MediumLevelILModsRec
Ord)

data MediumLevelILModsDpRec = MediumLevelILModsDpRec
  { MediumLevelILModsDpRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILModsDpRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILModsDpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILModsDpRec -> ShowS
[MediumLevelILModsDpRec] -> ShowS
MediumLevelILModsDpRec -> String
(Int -> MediumLevelILModsDpRec -> ShowS)
-> (MediumLevelILModsDpRec -> String)
-> ([MediumLevelILModsDpRec] -> ShowS)
-> Show MediumLevelILModsDpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILModsDpRec -> ShowS
showsPrec :: Int -> MediumLevelILModsDpRec -> ShowS
$cshow :: MediumLevelILModsDpRec -> String
show :: MediumLevelILModsDpRec -> String
$cshowList :: [MediumLevelILModsDpRec] -> ShowS
showList :: [MediumLevelILModsDpRec] -> ShowS
Show, MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
(MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> (MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> Eq MediumLevelILModsDpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
== :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
$c/= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
/= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
Eq, Eq MediumLevelILModsDpRec
Eq MediumLevelILModsDpRec =>
(MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Ordering)
-> (MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> (MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> (MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> (MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool)
-> (MediumLevelILModsDpRec
    -> MediumLevelILModsDpRec -> MediumLevelILModsDpRec)
-> (MediumLevelILModsDpRec
    -> MediumLevelILModsDpRec -> MediumLevelILModsDpRec)
-> Ord MediumLevelILModsDpRec
MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Ordering
MediumLevelILModsDpRec
-> MediumLevelILModsDpRec -> MediumLevelILModsDpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Ordering
compare :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Ordering
$c< :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
< :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
$c<= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
<= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
$c> :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
> :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
$c>= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
>= :: MediumLevelILModsDpRec -> MediumLevelILModsDpRec -> Bool
$cmax :: MediumLevelILModsDpRec
-> MediumLevelILModsDpRec -> MediumLevelILModsDpRec
max :: MediumLevelILModsDpRec
-> MediumLevelILModsDpRec -> MediumLevelILModsDpRec
$cmin :: MediumLevelILModsDpRec
-> MediumLevelILModsDpRec -> MediumLevelILModsDpRec
min :: MediumLevelILModsDpRec
-> MediumLevelILModsDpRec -> MediumLevelILModsDpRec
Ord)

data MediumLevelILAddOverflowRec = MediumLevelILAddOverflowRec
  { MediumLevelILAddOverflowRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILAddOverflowRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILAddOverflowRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAddOverflowRec -> ShowS
[MediumLevelILAddOverflowRec] -> ShowS
MediumLevelILAddOverflowRec -> String
(Int -> MediumLevelILAddOverflowRec -> ShowS)
-> (MediumLevelILAddOverflowRec -> String)
-> ([MediumLevelILAddOverflowRec] -> ShowS)
-> Show MediumLevelILAddOverflowRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAddOverflowRec -> ShowS
showsPrec :: Int -> MediumLevelILAddOverflowRec -> ShowS
$cshow :: MediumLevelILAddOverflowRec -> String
show :: MediumLevelILAddOverflowRec -> String
$cshowList :: [MediumLevelILAddOverflowRec] -> ShowS
showList :: [MediumLevelILAddOverflowRec] -> ShowS
Show, MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
(MediumLevelILAddOverflowRec
 -> MediumLevelILAddOverflowRec -> Bool)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> Bool)
-> Eq MediumLevelILAddOverflowRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
== :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
$c/= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
/= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
Eq, Eq MediumLevelILAddOverflowRec
Eq MediumLevelILAddOverflowRec =>
(MediumLevelILAddOverflowRec
 -> MediumLevelILAddOverflowRec -> Ordering)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> Bool)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> Bool)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> Bool)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> Bool)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec)
-> (MediumLevelILAddOverflowRec
    -> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec)
-> Ord MediumLevelILAddOverflowRec
MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> Ordering
MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> Ordering
compare :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> Ordering
$c< :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
< :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
$c<= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
<= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
$c> :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
> :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
$c>= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
>= :: MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec -> Bool
$cmax :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec
max :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec
$cmin :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec
min :: MediumLevelILAddOverflowRec
-> MediumLevelILAddOverflowRec -> MediumLevelILAddOverflowRec
Ord)

data MediumLevelILNoretRec = MediumLevelILNoretRec
  { MediumLevelILNoretRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILNoretRec -> ShowS
[MediumLevelILNoretRec] -> ShowS
MediumLevelILNoretRec -> String
(Int -> MediumLevelILNoretRec -> ShowS)
-> (MediumLevelILNoretRec -> String)
-> ([MediumLevelILNoretRec] -> ShowS)
-> Show MediumLevelILNoretRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILNoretRec -> ShowS
showsPrec :: Int -> MediumLevelILNoretRec -> ShowS
$cshow :: MediumLevelILNoretRec -> String
show :: MediumLevelILNoretRec -> String
$cshowList :: [MediumLevelILNoretRec] -> ShowS
showList :: [MediumLevelILNoretRec] -> ShowS
Show, MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
(MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> (MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> Eq MediumLevelILNoretRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
== :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
$c/= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
/= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
Eq, Eq MediumLevelILNoretRec
Eq MediumLevelILNoretRec =>
(MediumLevelILNoretRec -> MediumLevelILNoretRec -> Ordering)
-> (MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> (MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> (MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> (MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool)
-> (MediumLevelILNoretRec
    -> MediumLevelILNoretRec -> MediumLevelILNoretRec)
-> (MediumLevelILNoretRec
    -> MediumLevelILNoretRec -> MediumLevelILNoretRec)
-> Ord MediumLevelILNoretRec
MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
MediumLevelILNoretRec -> MediumLevelILNoretRec -> Ordering
MediumLevelILNoretRec
-> MediumLevelILNoretRec -> MediumLevelILNoretRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Ordering
compare :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Ordering
$c< :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
< :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
$c<= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
<= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
$c> :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
> :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
$c>= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
>= :: MediumLevelILNoretRec -> MediumLevelILNoretRec -> Bool
$cmax :: MediumLevelILNoretRec
-> MediumLevelILNoretRec -> MediumLevelILNoretRec
max :: MediumLevelILNoretRec
-> MediumLevelILNoretRec -> MediumLevelILNoretRec
$cmin :: MediumLevelILNoretRec
-> MediumLevelILNoretRec -> MediumLevelILNoretRec
min :: MediumLevelILNoretRec
-> MediumLevelILNoretRec -> MediumLevelILNoretRec
Ord)

data MediumLevelILStoreSsaRec = MediumLevelILStoreSsaRec
  { MediumLevelILStoreSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILStoreSsaRec -> Int
destMemory :: Int,
    MediumLevelILStoreSsaRec -> Int
srcMemory :: Int,
    MediumLevelILStoreSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILStoreSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILStoreSsaRec -> ShowS
[MediumLevelILStoreSsaRec] -> ShowS
MediumLevelILStoreSsaRec -> String
(Int -> MediumLevelILStoreSsaRec -> ShowS)
-> (MediumLevelILStoreSsaRec -> String)
-> ([MediumLevelILStoreSsaRec] -> ShowS)
-> Show MediumLevelILStoreSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILStoreSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILStoreSsaRec -> ShowS
$cshow :: MediumLevelILStoreSsaRec -> String
show :: MediumLevelILStoreSsaRec -> String
$cshowList :: [MediumLevelILStoreSsaRec] -> ShowS
showList :: [MediumLevelILStoreSsaRec] -> ShowS
Show, MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
(MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> (MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> Eq MediumLevelILStoreSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
== :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
$c/= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
/= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
Eq, Eq MediumLevelILStoreSsaRec
Eq MediumLevelILStoreSsaRec =>
(MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Ordering)
-> (MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> (MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> (MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> (MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool)
-> (MediumLevelILStoreSsaRec
    -> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec)
-> (MediumLevelILStoreSsaRec
    -> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec)
-> Ord MediumLevelILStoreSsaRec
MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Ordering
MediumLevelILStoreSsaRec
-> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Ordering
compare :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Ordering
$c< :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
< :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
$c<= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
<= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
$c> :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
> :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
$c>= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
>= :: MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec -> Bool
$cmax :: MediumLevelILStoreSsaRec
-> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec
max :: MediumLevelILStoreSsaRec
-> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec
$cmin :: MediumLevelILStoreSsaRec
-> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec
min :: MediumLevelILStoreSsaRec
-> MediumLevelILStoreSsaRec -> MediumLevelILStoreSsaRec
Ord)

data MediumLevelILSetVarSsaFieldRec = MediumLevelILSetVarSsaFieldRec
  { MediumLevelILSetVarSsaFieldRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILSetVarSsaFieldRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILSetVarSsaFieldRec -> Int
offset :: Int,
    MediumLevelILSetVarSsaFieldRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarSsaFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarSsaFieldRec -> ShowS
[MediumLevelILSetVarSsaFieldRec] -> ShowS
MediumLevelILSetVarSsaFieldRec -> String
(Int -> MediumLevelILSetVarSsaFieldRec -> ShowS)
-> (MediumLevelILSetVarSsaFieldRec -> String)
-> ([MediumLevelILSetVarSsaFieldRec] -> ShowS)
-> Show MediumLevelILSetVarSsaFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarSsaFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarSsaFieldRec -> ShowS
$cshow :: MediumLevelILSetVarSsaFieldRec -> String
show :: MediumLevelILSetVarSsaFieldRec -> String
$cshowList :: [MediumLevelILSetVarSsaFieldRec] -> ShowS
showList :: [MediumLevelILSetVarSsaFieldRec] -> ShowS
Show, MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
(MediumLevelILSetVarSsaFieldRec
 -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> Eq MediumLevelILSetVarSsaFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
== :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
$c/= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
/= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
Eq, Eq MediumLevelILSetVarSsaFieldRec
Eq MediumLevelILSetVarSsaFieldRec =>
(MediumLevelILSetVarSsaFieldRec
 -> MediumLevelILSetVarSsaFieldRec -> Ordering)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec -> Bool)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec)
-> (MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec
    -> MediumLevelILSetVarSsaFieldRec)
-> Ord MediumLevelILSetVarSsaFieldRec
MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Ordering
MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> MediumLevelILSetVarSsaFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Ordering
compare :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Ordering
$c< :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
< :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
$c<= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
<= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
$c> :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
> :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
$c>= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
>= :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> Bool
$cmax :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> MediumLevelILSetVarSsaFieldRec
max :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> MediumLevelILSetVarSsaFieldRec
$cmin :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> MediumLevelILSetVarSsaFieldRec
min :: MediumLevelILSetVarSsaFieldRec
-> MediumLevelILSetVarSsaFieldRec -> MediumLevelILSetVarSsaFieldRec
Ord)

data MediumLevelILSetVarAliasedRec = MediumLevelILSetVarAliasedRec
  { MediumLevelILSetVarAliasedRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILSetVarAliasedRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILSetVarAliasedRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarAliasedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarAliasedRec -> ShowS
[MediumLevelILSetVarAliasedRec] -> ShowS
MediumLevelILSetVarAliasedRec -> String
(Int -> MediumLevelILSetVarAliasedRec -> ShowS)
-> (MediumLevelILSetVarAliasedRec -> String)
-> ([MediumLevelILSetVarAliasedRec] -> ShowS)
-> Show MediumLevelILSetVarAliasedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarAliasedRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarAliasedRec -> ShowS
$cshow :: MediumLevelILSetVarAliasedRec -> String
show :: MediumLevelILSetVarAliasedRec -> String
$cshowList :: [MediumLevelILSetVarAliasedRec] -> ShowS
showList :: [MediumLevelILSetVarAliasedRec] -> ShowS
Show, MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
(MediumLevelILSetVarAliasedRec
 -> MediumLevelILSetVarAliasedRec -> Bool)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> Bool)
-> Eq MediumLevelILSetVarAliasedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
== :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
$c/= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
/= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
Eq, Eq MediumLevelILSetVarAliasedRec
Eq MediumLevelILSetVarAliasedRec =>
(MediumLevelILSetVarAliasedRec
 -> MediumLevelILSetVarAliasedRec -> Ordering)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> Bool)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> Bool)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> Bool)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> Bool)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec)
-> (MediumLevelILSetVarAliasedRec
    -> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec)
-> Ord MediumLevelILSetVarAliasedRec
MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Ordering
MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Ordering
compare :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Ordering
$c< :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
< :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
$c<= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
<= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
$c> :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
> :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
$c>= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
>= :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> Bool
$cmax :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec
max :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec
$cmin :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec
min :: MediumLevelILSetVarAliasedRec
-> MediumLevelILSetVarAliasedRec -> MediumLevelILSetVarAliasedRec
Ord)

data MediumLevelILVarSsaFieldRec = MediumLevelILVarSsaFieldRec
  { MediumLevelILVarSsaFieldRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILVarSsaFieldRec -> Int
offset :: Int,
    MediumLevelILVarSsaFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarSsaFieldRec -> ShowS
[MediumLevelILVarSsaFieldRec] -> ShowS
MediumLevelILVarSsaFieldRec -> String
(Int -> MediumLevelILVarSsaFieldRec -> ShowS)
-> (MediumLevelILVarSsaFieldRec -> String)
-> ([MediumLevelILVarSsaFieldRec] -> ShowS)
-> Show MediumLevelILVarSsaFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarSsaFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarSsaFieldRec -> ShowS
$cshow :: MediumLevelILVarSsaFieldRec -> String
show :: MediumLevelILVarSsaFieldRec -> String
$cshowList :: [MediumLevelILVarSsaFieldRec] -> ShowS
showList :: [MediumLevelILVarSsaFieldRec] -> ShowS
Show, MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
(MediumLevelILVarSsaFieldRec
 -> MediumLevelILVarSsaFieldRec -> Bool)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> Bool)
-> Eq MediumLevelILVarSsaFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
== :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
$c/= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
/= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
Eq, Eq MediumLevelILVarSsaFieldRec
Eq MediumLevelILVarSsaFieldRec =>
(MediumLevelILVarSsaFieldRec
 -> MediumLevelILVarSsaFieldRec -> Ordering)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> Bool)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> Bool)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> Bool)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> Bool)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec)
-> (MediumLevelILVarSsaFieldRec
    -> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec)
-> Ord MediumLevelILVarSsaFieldRec
MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> Ordering
MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> Ordering
compare :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> Ordering
$c< :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
< :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
$c<= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
<= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
$c> :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
> :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
$c>= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
>= :: MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec -> Bool
$cmax :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec
max :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec
$cmin :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec
min :: MediumLevelILVarSsaFieldRec
-> MediumLevelILVarSsaFieldRec -> MediumLevelILVarSsaFieldRec
Ord)

data MediumLevelILGotoRec = MediumLevelILGotoRec
  { MediumLevelILGotoRec -> Int
dest :: Int, -- InstructionIndex
    MediumLevelILGotoRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILGotoRec -> ShowS
[MediumLevelILGotoRec] -> ShowS
MediumLevelILGotoRec -> String
(Int -> MediumLevelILGotoRec -> ShowS)
-> (MediumLevelILGotoRec -> String)
-> ([MediumLevelILGotoRec] -> ShowS)
-> Show MediumLevelILGotoRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILGotoRec -> ShowS
showsPrec :: Int -> MediumLevelILGotoRec -> ShowS
$cshow :: MediumLevelILGotoRec -> String
show :: MediumLevelILGotoRec -> String
$cshowList :: [MediumLevelILGotoRec] -> ShowS
showList :: [MediumLevelILGotoRec] -> ShowS
Show, MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
(MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> (MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> Eq MediumLevelILGotoRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
== :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
$c/= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
/= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
Eq, Eq MediumLevelILGotoRec
Eq MediumLevelILGotoRec =>
(MediumLevelILGotoRec -> MediumLevelILGotoRec -> Ordering)
-> (MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> (MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> (MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> (MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool)
-> (MediumLevelILGotoRec
    -> MediumLevelILGotoRec -> MediumLevelILGotoRec)
-> (MediumLevelILGotoRec
    -> MediumLevelILGotoRec -> MediumLevelILGotoRec)
-> Ord MediumLevelILGotoRec
MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
MediumLevelILGotoRec -> MediumLevelILGotoRec -> Ordering
MediumLevelILGotoRec
-> MediumLevelILGotoRec -> MediumLevelILGotoRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Ordering
compare :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Ordering
$c< :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
< :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
$c<= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
<= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
$c> :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
> :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
$c>= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
>= :: MediumLevelILGotoRec -> MediumLevelILGotoRec -> Bool
$cmax :: MediumLevelILGotoRec
-> MediumLevelILGotoRec -> MediumLevelILGotoRec
max :: MediumLevelILGotoRec
-> MediumLevelILGotoRec -> MediumLevelILGotoRec
$cmin :: MediumLevelILGotoRec
-> MediumLevelILGotoRec -> MediumLevelILGotoRec
min :: MediumLevelILGotoRec
-> MediumLevelILGotoRec -> MediumLevelILGotoRec
Ord)

data MediumLevelILAddRec = MediumLevelILAddRec
  { MediumLevelILAddRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILAddRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILAddRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAddRec -> ShowS
[MediumLevelILAddRec] -> ShowS
MediumLevelILAddRec -> String
(Int -> MediumLevelILAddRec -> ShowS)
-> (MediumLevelILAddRec -> String)
-> ([MediumLevelILAddRec] -> ShowS)
-> Show MediumLevelILAddRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAddRec -> ShowS
showsPrec :: Int -> MediumLevelILAddRec -> ShowS
$cshow :: MediumLevelILAddRec -> String
show :: MediumLevelILAddRec -> String
$cshowList :: [MediumLevelILAddRec] -> ShowS
showList :: [MediumLevelILAddRec] -> ShowS
Show, MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
(MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> (MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> Eq MediumLevelILAddRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
== :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
$c/= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
/= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
Eq, Eq MediumLevelILAddRec
Eq MediumLevelILAddRec =>
(MediumLevelILAddRec -> MediumLevelILAddRec -> Ordering)
-> (MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> (MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> (MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> (MediumLevelILAddRec -> MediumLevelILAddRec -> Bool)
-> (MediumLevelILAddRec
    -> MediumLevelILAddRec -> MediumLevelILAddRec)
-> (MediumLevelILAddRec
    -> MediumLevelILAddRec -> MediumLevelILAddRec)
-> Ord MediumLevelILAddRec
MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
MediumLevelILAddRec -> MediumLevelILAddRec -> Ordering
MediumLevelILAddRec -> MediumLevelILAddRec -> MediumLevelILAddRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAddRec -> MediumLevelILAddRec -> Ordering
compare :: MediumLevelILAddRec -> MediumLevelILAddRec -> Ordering
$c< :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
< :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
$c<= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
<= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
$c> :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
> :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
$c>= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
>= :: MediumLevelILAddRec -> MediumLevelILAddRec -> Bool
$cmax :: MediumLevelILAddRec -> MediumLevelILAddRec -> MediumLevelILAddRec
max :: MediumLevelILAddRec -> MediumLevelILAddRec -> MediumLevelILAddRec
$cmin :: MediumLevelILAddRec -> MediumLevelILAddRec -> MediumLevelILAddRec
min :: MediumLevelILAddRec -> MediumLevelILAddRec -> MediumLevelILAddRec
Ord)

data MediumLevelILSubRec = MediumLevelILSubRec
  { MediumLevelILSubRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILSubRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILSubRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSubRec -> ShowS
[MediumLevelILSubRec] -> ShowS
MediumLevelILSubRec -> String
(Int -> MediumLevelILSubRec -> ShowS)
-> (MediumLevelILSubRec -> String)
-> ([MediumLevelILSubRec] -> ShowS)
-> Show MediumLevelILSubRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSubRec -> ShowS
showsPrec :: Int -> MediumLevelILSubRec -> ShowS
$cshow :: MediumLevelILSubRec -> String
show :: MediumLevelILSubRec -> String
$cshowList :: [MediumLevelILSubRec] -> ShowS
showList :: [MediumLevelILSubRec] -> ShowS
Show, MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
(MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> (MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> Eq MediumLevelILSubRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
== :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
$c/= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
/= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
Eq, Eq MediumLevelILSubRec
Eq MediumLevelILSubRec =>
(MediumLevelILSubRec -> MediumLevelILSubRec -> Ordering)
-> (MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> (MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> (MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> (MediumLevelILSubRec -> MediumLevelILSubRec -> Bool)
-> (MediumLevelILSubRec
    -> MediumLevelILSubRec -> MediumLevelILSubRec)
-> (MediumLevelILSubRec
    -> MediumLevelILSubRec -> MediumLevelILSubRec)
-> Ord MediumLevelILSubRec
MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
MediumLevelILSubRec -> MediumLevelILSubRec -> Ordering
MediumLevelILSubRec -> MediumLevelILSubRec -> MediumLevelILSubRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSubRec -> MediumLevelILSubRec -> Ordering
compare :: MediumLevelILSubRec -> MediumLevelILSubRec -> Ordering
$c< :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
< :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
$c<= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
<= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
$c> :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
> :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
$c>= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
>= :: MediumLevelILSubRec -> MediumLevelILSubRec -> Bool
$cmax :: MediumLevelILSubRec -> MediumLevelILSubRec -> MediumLevelILSubRec
max :: MediumLevelILSubRec -> MediumLevelILSubRec -> MediumLevelILSubRec
$cmin :: MediumLevelILSubRec -> MediumLevelILSubRec -> MediumLevelILSubRec
min :: MediumLevelILSubRec -> MediumLevelILSubRec -> MediumLevelILSubRec
Ord)

data MediumLevelILNegRec = MediumLevelILNegRec
  { MediumLevelILNegRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILNegRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILNegRec -> ShowS
[MediumLevelILNegRec] -> ShowS
MediumLevelILNegRec -> String
(Int -> MediumLevelILNegRec -> ShowS)
-> (MediumLevelILNegRec -> String)
-> ([MediumLevelILNegRec] -> ShowS)
-> Show MediumLevelILNegRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILNegRec -> ShowS
showsPrec :: Int -> MediumLevelILNegRec -> ShowS
$cshow :: MediumLevelILNegRec -> String
show :: MediumLevelILNegRec -> String
$cshowList :: [MediumLevelILNegRec] -> ShowS
showList :: [MediumLevelILNegRec] -> ShowS
Show, MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
(MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> (MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> Eq MediumLevelILNegRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
== :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
$c/= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
/= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
Eq, Eq MediumLevelILNegRec
Eq MediumLevelILNegRec =>
(MediumLevelILNegRec -> MediumLevelILNegRec -> Ordering)
-> (MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> (MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> (MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> (MediumLevelILNegRec -> MediumLevelILNegRec -> Bool)
-> (MediumLevelILNegRec
    -> MediumLevelILNegRec -> MediumLevelILNegRec)
-> (MediumLevelILNegRec
    -> MediumLevelILNegRec -> MediumLevelILNegRec)
-> Ord MediumLevelILNegRec
MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
MediumLevelILNegRec -> MediumLevelILNegRec -> Ordering
MediumLevelILNegRec -> MediumLevelILNegRec -> MediumLevelILNegRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILNegRec -> MediumLevelILNegRec -> Ordering
compare :: MediumLevelILNegRec -> MediumLevelILNegRec -> Ordering
$c< :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
< :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
$c<= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
<= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
$c> :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
> :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
$c>= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
>= :: MediumLevelILNegRec -> MediumLevelILNegRec -> Bool
$cmax :: MediumLevelILNegRec -> MediumLevelILNegRec -> MediumLevelILNegRec
max :: MediumLevelILNegRec -> MediumLevelILNegRec -> MediumLevelILNegRec
$cmin :: MediumLevelILNegRec -> MediumLevelILNegRec -> MediumLevelILNegRec
min :: MediumLevelILNegRec -> MediumLevelILNegRec -> MediumLevelILNegRec
Ord)

data MediumLevelILNotRec = MediumLevelILNotRec
  { MediumLevelILNotRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILNotRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILNotRec -> ShowS
[MediumLevelILNotRec] -> ShowS
MediumLevelILNotRec -> String
(Int -> MediumLevelILNotRec -> ShowS)
-> (MediumLevelILNotRec -> String)
-> ([MediumLevelILNotRec] -> ShowS)
-> Show MediumLevelILNotRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILNotRec -> ShowS
showsPrec :: Int -> MediumLevelILNotRec -> ShowS
$cshow :: MediumLevelILNotRec -> String
show :: MediumLevelILNotRec -> String
$cshowList :: [MediumLevelILNotRec] -> ShowS
showList :: [MediumLevelILNotRec] -> ShowS
Show, MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
(MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> (MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> Eq MediumLevelILNotRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
== :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
$c/= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
/= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
Eq, Eq MediumLevelILNotRec
Eq MediumLevelILNotRec =>
(MediumLevelILNotRec -> MediumLevelILNotRec -> Ordering)
-> (MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> (MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> (MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> (MediumLevelILNotRec -> MediumLevelILNotRec -> Bool)
-> (MediumLevelILNotRec
    -> MediumLevelILNotRec -> MediumLevelILNotRec)
-> (MediumLevelILNotRec
    -> MediumLevelILNotRec -> MediumLevelILNotRec)
-> Ord MediumLevelILNotRec
MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
MediumLevelILNotRec -> MediumLevelILNotRec -> Ordering
MediumLevelILNotRec -> MediumLevelILNotRec -> MediumLevelILNotRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILNotRec -> MediumLevelILNotRec -> Ordering
compare :: MediumLevelILNotRec -> MediumLevelILNotRec -> Ordering
$c< :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
< :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
$c<= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
<= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
$c> :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
> :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
$c>= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
>= :: MediumLevelILNotRec -> MediumLevelILNotRec -> Bool
$cmax :: MediumLevelILNotRec -> MediumLevelILNotRec -> MediumLevelILNotRec
max :: MediumLevelILNotRec -> MediumLevelILNotRec -> MediumLevelILNotRec
$cmin :: MediumLevelILNotRec -> MediumLevelILNotRec -> MediumLevelILNotRec
min :: MediumLevelILNotRec -> MediumLevelILNotRec -> MediumLevelILNotRec
Ord)

data MediumLevelILSxRec = MediumLevelILSxRec
  { MediumLevelILSxRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSxRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSxRec -> ShowS
[MediumLevelILSxRec] -> ShowS
MediumLevelILSxRec -> String
(Int -> MediumLevelILSxRec -> ShowS)
-> (MediumLevelILSxRec -> String)
-> ([MediumLevelILSxRec] -> ShowS)
-> Show MediumLevelILSxRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSxRec -> ShowS
showsPrec :: Int -> MediumLevelILSxRec -> ShowS
$cshow :: MediumLevelILSxRec -> String
show :: MediumLevelILSxRec -> String
$cshowList :: [MediumLevelILSxRec] -> ShowS
showList :: [MediumLevelILSxRec] -> ShowS
Show, MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
(MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> Eq MediumLevelILSxRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
== :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
$c/= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
/= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
Eq, Eq MediumLevelILSxRec
Eq MediumLevelILSxRec =>
(MediumLevelILSxRec -> MediumLevelILSxRec -> Ordering)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> Bool)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec)
-> (MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec)
-> Ord MediumLevelILSxRec
MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
MediumLevelILSxRec -> MediumLevelILSxRec -> Ordering
MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSxRec -> MediumLevelILSxRec -> Ordering
compare :: MediumLevelILSxRec -> MediumLevelILSxRec -> Ordering
$c< :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
< :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
$c<= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
<= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
$c> :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
> :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
$c>= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
>= :: MediumLevelILSxRec -> MediumLevelILSxRec -> Bool
$cmax :: MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec
max :: MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec
$cmin :: MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec
min :: MediumLevelILSxRec -> MediumLevelILSxRec -> MediumLevelILSxRec
Ord)

data MediumLevelILZxRec = MediumLevelILZxRec
  { MediumLevelILZxRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILZxRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILZxRec -> ShowS
[MediumLevelILZxRec] -> ShowS
MediumLevelILZxRec -> String
(Int -> MediumLevelILZxRec -> ShowS)
-> (MediumLevelILZxRec -> String)
-> ([MediumLevelILZxRec] -> ShowS)
-> Show MediumLevelILZxRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILZxRec -> ShowS
showsPrec :: Int -> MediumLevelILZxRec -> ShowS
$cshow :: MediumLevelILZxRec -> String
show :: MediumLevelILZxRec -> String
$cshowList :: [MediumLevelILZxRec] -> ShowS
showList :: [MediumLevelILZxRec] -> ShowS
Show, MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
(MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> Eq MediumLevelILZxRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
== :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
$c/= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
/= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
Eq, Eq MediumLevelILZxRec
Eq MediumLevelILZxRec =>
(MediumLevelILZxRec -> MediumLevelILZxRec -> Ordering)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> Bool)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec)
-> (MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec)
-> Ord MediumLevelILZxRec
MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
MediumLevelILZxRec -> MediumLevelILZxRec -> Ordering
MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILZxRec -> MediumLevelILZxRec -> Ordering
compare :: MediumLevelILZxRec -> MediumLevelILZxRec -> Ordering
$c< :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
< :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
$c<= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
<= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
$c> :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
> :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
$c>= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
>= :: MediumLevelILZxRec -> MediumLevelILZxRec -> Bool
$cmax :: MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec
max :: MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec
$cmin :: MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec
min :: MediumLevelILZxRec -> MediumLevelILZxRec -> MediumLevelILZxRec
Ord)

data MediumLevelILLowPartRec = MediumLevelILLowPartRec
  { MediumLevelILLowPartRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILLowPartRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLowPartRec -> ShowS
[MediumLevelILLowPartRec] -> ShowS
MediumLevelILLowPartRec -> String
(Int -> MediumLevelILLowPartRec -> ShowS)
-> (MediumLevelILLowPartRec -> String)
-> ([MediumLevelILLowPartRec] -> ShowS)
-> Show MediumLevelILLowPartRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLowPartRec -> ShowS
showsPrec :: Int -> MediumLevelILLowPartRec -> ShowS
$cshow :: MediumLevelILLowPartRec -> String
show :: MediumLevelILLowPartRec -> String
$cshowList :: [MediumLevelILLowPartRec] -> ShowS
showList :: [MediumLevelILLowPartRec] -> ShowS
Show, MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
(MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> (MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> Eq MediumLevelILLowPartRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
== :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
$c/= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
/= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
Eq, Eq MediumLevelILLowPartRec
Eq MediumLevelILLowPartRec =>
(MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Ordering)
-> (MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> (MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> (MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> (MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool)
-> (MediumLevelILLowPartRec
    -> MediumLevelILLowPartRec -> MediumLevelILLowPartRec)
-> (MediumLevelILLowPartRec
    -> MediumLevelILLowPartRec -> MediumLevelILLowPartRec)
-> Ord MediumLevelILLowPartRec
MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Ordering
MediumLevelILLowPartRec
-> MediumLevelILLowPartRec -> MediumLevelILLowPartRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Ordering
compare :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Ordering
$c< :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
< :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
$c<= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
<= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
$c> :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
> :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
$c>= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
>= :: MediumLevelILLowPartRec -> MediumLevelILLowPartRec -> Bool
$cmax :: MediumLevelILLowPartRec
-> MediumLevelILLowPartRec -> MediumLevelILLowPartRec
max :: MediumLevelILLowPartRec
-> MediumLevelILLowPartRec -> MediumLevelILLowPartRec
$cmin :: MediumLevelILLowPartRec
-> MediumLevelILLowPartRec -> MediumLevelILLowPartRec
min :: MediumLevelILLowPartRec
-> MediumLevelILLowPartRec -> MediumLevelILLowPartRec
Ord)

data MediumLevelILFsqrtRec = MediumLevelILFsqrtRec
  { MediumLevelILFsqrtRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFsqrtRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFsqrtRec -> ShowS
[MediumLevelILFsqrtRec] -> ShowS
MediumLevelILFsqrtRec -> String
(Int -> MediumLevelILFsqrtRec -> ShowS)
-> (MediumLevelILFsqrtRec -> String)
-> ([MediumLevelILFsqrtRec] -> ShowS)
-> Show MediumLevelILFsqrtRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFsqrtRec -> ShowS
showsPrec :: Int -> MediumLevelILFsqrtRec -> ShowS
$cshow :: MediumLevelILFsqrtRec -> String
show :: MediumLevelILFsqrtRec -> String
$cshowList :: [MediumLevelILFsqrtRec] -> ShowS
showList :: [MediumLevelILFsqrtRec] -> ShowS
Show, MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
(MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> (MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> Eq MediumLevelILFsqrtRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
== :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
$c/= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
/= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
Eq, Eq MediumLevelILFsqrtRec
Eq MediumLevelILFsqrtRec =>
(MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Ordering)
-> (MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> (MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> (MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> (MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool)
-> (MediumLevelILFsqrtRec
    -> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec)
-> (MediumLevelILFsqrtRec
    -> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec)
-> Ord MediumLevelILFsqrtRec
MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Ordering
MediumLevelILFsqrtRec
-> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Ordering
compare :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Ordering
$c< :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
< :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
$c<= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
<= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
$c> :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
> :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
$c>= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
>= :: MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec -> Bool
$cmax :: MediumLevelILFsqrtRec
-> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec
max :: MediumLevelILFsqrtRec
-> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec
$cmin :: MediumLevelILFsqrtRec
-> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec
min :: MediumLevelILFsqrtRec
-> MediumLevelILFsqrtRec -> MediumLevelILFsqrtRec
Ord)

data MediumLevelILFnegRec = MediumLevelILFnegRec
  { MediumLevelILFnegRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFnegRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFnegRec -> ShowS
[MediumLevelILFnegRec] -> ShowS
MediumLevelILFnegRec -> String
(Int -> MediumLevelILFnegRec -> ShowS)
-> (MediumLevelILFnegRec -> String)
-> ([MediumLevelILFnegRec] -> ShowS)
-> Show MediumLevelILFnegRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFnegRec -> ShowS
showsPrec :: Int -> MediumLevelILFnegRec -> ShowS
$cshow :: MediumLevelILFnegRec -> String
show :: MediumLevelILFnegRec -> String
$cshowList :: [MediumLevelILFnegRec] -> ShowS
showList :: [MediumLevelILFnegRec] -> ShowS
Show, MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
(MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> (MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> Eq MediumLevelILFnegRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
== :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
$c/= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
/= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
Eq, Eq MediumLevelILFnegRec
Eq MediumLevelILFnegRec =>
(MediumLevelILFnegRec -> MediumLevelILFnegRec -> Ordering)
-> (MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> (MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> (MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> (MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool)
-> (MediumLevelILFnegRec
    -> MediumLevelILFnegRec -> MediumLevelILFnegRec)
-> (MediumLevelILFnegRec
    -> MediumLevelILFnegRec -> MediumLevelILFnegRec)
-> Ord MediumLevelILFnegRec
MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
MediumLevelILFnegRec -> MediumLevelILFnegRec -> Ordering
MediumLevelILFnegRec
-> MediumLevelILFnegRec -> MediumLevelILFnegRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Ordering
compare :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Ordering
$c< :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
< :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
$c<= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
<= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
$c> :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
> :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
$c>= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
>= :: MediumLevelILFnegRec -> MediumLevelILFnegRec -> Bool
$cmax :: MediumLevelILFnegRec
-> MediumLevelILFnegRec -> MediumLevelILFnegRec
max :: MediumLevelILFnegRec
-> MediumLevelILFnegRec -> MediumLevelILFnegRec
$cmin :: MediumLevelILFnegRec
-> MediumLevelILFnegRec -> MediumLevelILFnegRec
min :: MediumLevelILFnegRec
-> MediumLevelILFnegRec -> MediumLevelILFnegRec
Ord)

data MediumLevelILFabsRec = MediumLevelILFabsRec
  { MediumLevelILFabsRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFabsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFabsRec -> ShowS
[MediumLevelILFabsRec] -> ShowS
MediumLevelILFabsRec -> String
(Int -> MediumLevelILFabsRec -> ShowS)
-> (MediumLevelILFabsRec -> String)
-> ([MediumLevelILFabsRec] -> ShowS)
-> Show MediumLevelILFabsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFabsRec -> ShowS
showsPrec :: Int -> MediumLevelILFabsRec -> ShowS
$cshow :: MediumLevelILFabsRec -> String
show :: MediumLevelILFabsRec -> String
$cshowList :: [MediumLevelILFabsRec] -> ShowS
showList :: [MediumLevelILFabsRec] -> ShowS
Show, MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
(MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> (MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> Eq MediumLevelILFabsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
== :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
$c/= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
/= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
Eq, Eq MediumLevelILFabsRec
Eq MediumLevelILFabsRec =>
(MediumLevelILFabsRec -> MediumLevelILFabsRec -> Ordering)
-> (MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> (MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> (MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> (MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool)
-> (MediumLevelILFabsRec
    -> MediumLevelILFabsRec -> MediumLevelILFabsRec)
-> (MediumLevelILFabsRec
    -> MediumLevelILFabsRec -> MediumLevelILFabsRec)
-> Ord MediumLevelILFabsRec
MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
MediumLevelILFabsRec -> MediumLevelILFabsRec -> Ordering
MediumLevelILFabsRec
-> MediumLevelILFabsRec -> MediumLevelILFabsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Ordering
compare :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Ordering
$c< :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
< :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
$c<= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
<= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
$c> :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
> :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
$c>= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
>= :: MediumLevelILFabsRec -> MediumLevelILFabsRec -> Bool
$cmax :: MediumLevelILFabsRec
-> MediumLevelILFabsRec -> MediumLevelILFabsRec
max :: MediumLevelILFabsRec
-> MediumLevelILFabsRec -> MediumLevelILFabsRec
$cmin :: MediumLevelILFabsRec
-> MediumLevelILFabsRec -> MediumLevelILFabsRec
min :: MediumLevelILFabsRec
-> MediumLevelILFabsRec -> MediumLevelILFabsRec
Ord)

data MediumLevelILFloatToIntRec = MediumLevelILFloatToIntRec
  { MediumLevelILFloatToIntRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFloatToIntRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFloatToIntRec -> ShowS
[MediumLevelILFloatToIntRec] -> ShowS
MediumLevelILFloatToIntRec -> String
(Int -> MediumLevelILFloatToIntRec -> ShowS)
-> (MediumLevelILFloatToIntRec -> String)
-> ([MediumLevelILFloatToIntRec] -> ShowS)
-> Show MediumLevelILFloatToIntRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFloatToIntRec -> ShowS
showsPrec :: Int -> MediumLevelILFloatToIntRec -> ShowS
$cshow :: MediumLevelILFloatToIntRec -> String
show :: MediumLevelILFloatToIntRec -> String
$cshowList :: [MediumLevelILFloatToIntRec] -> ShowS
showList :: [MediumLevelILFloatToIntRec] -> ShowS
Show, MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
(MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> Bool)
-> Eq MediumLevelILFloatToIntRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
== :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
$c/= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
/= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
Eq, Eq MediumLevelILFloatToIntRec
Eq MediumLevelILFloatToIntRec =>
(MediumLevelILFloatToIntRec
 -> MediumLevelILFloatToIntRec -> Ordering)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> Bool)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> Bool)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> Bool)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> Bool)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec)
-> (MediumLevelILFloatToIntRec
    -> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec)
-> Ord MediumLevelILFloatToIntRec
MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> Ordering
MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> Ordering
compare :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> Ordering
$c< :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
< :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
$c<= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
<= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
$c> :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
> :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
$c>= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
>= :: MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec -> Bool
$cmax :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec
max :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec
$cmin :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec
min :: MediumLevelILFloatToIntRec
-> MediumLevelILFloatToIntRec -> MediumLevelILFloatToIntRec
Ord)

data MediumLevelILIntToFloatRec = MediumLevelILIntToFloatRec
  { MediumLevelILIntToFloatRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILIntToFloatRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILIntToFloatRec -> ShowS
[MediumLevelILIntToFloatRec] -> ShowS
MediumLevelILIntToFloatRec -> String
(Int -> MediumLevelILIntToFloatRec -> ShowS)
-> (MediumLevelILIntToFloatRec -> String)
-> ([MediumLevelILIntToFloatRec] -> ShowS)
-> Show MediumLevelILIntToFloatRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILIntToFloatRec -> ShowS
showsPrec :: Int -> MediumLevelILIntToFloatRec -> ShowS
$cshow :: MediumLevelILIntToFloatRec -> String
show :: MediumLevelILIntToFloatRec -> String
$cshowList :: [MediumLevelILIntToFloatRec] -> ShowS
showList :: [MediumLevelILIntToFloatRec] -> ShowS
Show, MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
(MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> Bool)
-> Eq MediumLevelILIntToFloatRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
== :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
$c/= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
/= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
Eq, Eq MediumLevelILIntToFloatRec
Eq MediumLevelILIntToFloatRec =>
(MediumLevelILIntToFloatRec
 -> MediumLevelILIntToFloatRec -> Ordering)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> Bool)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> Bool)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> Bool)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> Bool)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec)
-> (MediumLevelILIntToFloatRec
    -> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec)
-> Ord MediumLevelILIntToFloatRec
MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> Ordering
MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> Ordering
compare :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> Ordering
$c< :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
< :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
$c<= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
<= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
$c> :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
> :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
$c>= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
>= :: MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec -> Bool
$cmax :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec
max :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec
$cmin :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec
min :: MediumLevelILIntToFloatRec
-> MediumLevelILIntToFloatRec -> MediumLevelILIntToFloatRec
Ord)

data MediumLevelILFloatConvRec = MediumLevelILFloatConvRec
  { MediumLevelILFloatConvRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFloatConvRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFloatConvRec -> ShowS
[MediumLevelILFloatConvRec] -> ShowS
MediumLevelILFloatConvRec -> String
(Int -> MediumLevelILFloatConvRec -> ShowS)
-> (MediumLevelILFloatConvRec -> String)
-> ([MediumLevelILFloatConvRec] -> ShowS)
-> Show MediumLevelILFloatConvRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFloatConvRec -> ShowS
showsPrec :: Int -> MediumLevelILFloatConvRec -> ShowS
$cshow :: MediumLevelILFloatConvRec -> String
show :: MediumLevelILFloatConvRec -> String
$cshowList :: [MediumLevelILFloatConvRec] -> ShowS
showList :: [MediumLevelILFloatConvRec] -> ShowS
Show, MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
(MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> (MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> Eq MediumLevelILFloatConvRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
== :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
$c/= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
/= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
Eq, Eq MediumLevelILFloatConvRec
Eq MediumLevelILFloatConvRec =>
(MediumLevelILFloatConvRec
 -> MediumLevelILFloatConvRec -> Ordering)
-> (MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> (MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> (MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> (MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool)
-> (MediumLevelILFloatConvRec
    -> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec)
-> (MediumLevelILFloatConvRec
    -> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec)
-> Ord MediumLevelILFloatConvRec
MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Ordering
MediumLevelILFloatConvRec
-> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Ordering
compare :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Ordering
$c< :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
< :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
$c<= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
<= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
$c> :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
> :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
$c>= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
>= :: MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec -> Bool
$cmax :: MediumLevelILFloatConvRec
-> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec
max :: MediumLevelILFloatConvRec
-> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec
$cmin :: MediumLevelILFloatConvRec
-> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec
min :: MediumLevelILFloatConvRec
-> MediumLevelILFloatConvRec -> MediumLevelILFloatConvRec
Ord)

data MediumLevelILRoundToIntRec = MediumLevelILRoundToIntRec
  { MediumLevelILRoundToIntRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILRoundToIntRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRoundToIntRec -> ShowS
[MediumLevelILRoundToIntRec] -> ShowS
MediumLevelILRoundToIntRec -> String
(Int -> MediumLevelILRoundToIntRec -> ShowS)
-> (MediumLevelILRoundToIntRec -> String)
-> ([MediumLevelILRoundToIntRec] -> ShowS)
-> Show MediumLevelILRoundToIntRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRoundToIntRec -> ShowS
showsPrec :: Int -> MediumLevelILRoundToIntRec -> ShowS
$cshow :: MediumLevelILRoundToIntRec -> String
show :: MediumLevelILRoundToIntRec -> String
$cshowList :: [MediumLevelILRoundToIntRec] -> ShowS
showList :: [MediumLevelILRoundToIntRec] -> ShowS
Show, MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
(MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> Bool)
-> Eq MediumLevelILRoundToIntRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
== :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
$c/= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
/= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
Eq, Eq MediumLevelILRoundToIntRec
Eq MediumLevelILRoundToIntRec =>
(MediumLevelILRoundToIntRec
 -> MediumLevelILRoundToIntRec -> Ordering)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> Bool)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> Bool)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> Bool)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> Bool)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec)
-> (MediumLevelILRoundToIntRec
    -> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec)
-> Ord MediumLevelILRoundToIntRec
MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> Ordering
MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> Ordering
compare :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> Ordering
$c< :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
< :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
$c<= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
<= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
$c> :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
> :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
$c>= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
>= :: MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec -> Bool
$cmax :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec
max :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec
$cmin :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec
min :: MediumLevelILRoundToIntRec
-> MediumLevelILRoundToIntRec -> MediumLevelILRoundToIntRec
Ord)

data MediumLevelILFloorRec = MediumLevelILFloorRec
  { MediumLevelILFloorRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFloorRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFloorRec -> ShowS
[MediumLevelILFloorRec] -> ShowS
MediumLevelILFloorRec -> String
(Int -> MediumLevelILFloorRec -> ShowS)
-> (MediumLevelILFloorRec -> String)
-> ([MediumLevelILFloorRec] -> ShowS)
-> Show MediumLevelILFloorRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFloorRec -> ShowS
showsPrec :: Int -> MediumLevelILFloorRec -> ShowS
$cshow :: MediumLevelILFloorRec -> String
show :: MediumLevelILFloorRec -> String
$cshowList :: [MediumLevelILFloorRec] -> ShowS
showList :: [MediumLevelILFloorRec] -> ShowS
Show, MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
(MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> (MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> Eq MediumLevelILFloorRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
== :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
$c/= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
/= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
Eq, Eq MediumLevelILFloorRec
Eq MediumLevelILFloorRec =>
(MediumLevelILFloorRec -> MediumLevelILFloorRec -> Ordering)
-> (MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> (MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> (MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> (MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool)
-> (MediumLevelILFloorRec
    -> MediumLevelILFloorRec -> MediumLevelILFloorRec)
-> (MediumLevelILFloorRec
    -> MediumLevelILFloorRec -> MediumLevelILFloorRec)
-> Ord MediumLevelILFloorRec
MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
MediumLevelILFloorRec -> MediumLevelILFloorRec -> Ordering
MediumLevelILFloorRec
-> MediumLevelILFloorRec -> MediumLevelILFloorRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Ordering
compare :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Ordering
$c< :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
< :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
$c<= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
<= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
$c> :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
> :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
$c>= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
>= :: MediumLevelILFloorRec -> MediumLevelILFloorRec -> Bool
$cmax :: MediumLevelILFloorRec
-> MediumLevelILFloorRec -> MediumLevelILFloorRec
max :: MediumLevelILFloorRec
-> MediumLevelILFloorRec -> MediumLevelILFloorRec
$cmin :: MediumLevelILFloorRec
-> MediumLevelILFloorRec -> MediumLevelILFloorRec
min :: MediumLevelILFloorRec
-> MediumLevelILFloorRec -> MediumLevelILFloorRec
Ord)

data MediumLevelILCeilRec = MediumLevelILCeilRec
  { MediumLevelILCeilRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILCeilRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCeilRec -> ShowS
[MediumLevelILCeilRec] -> ShowS
MediumLevelILCeilRec -> String
(Int -> MediumLevelILCeilRec -> ShowS)
-> (MediumLevelILCeilRec -> String)
-> ([MediumLevelILCeilRec] -> ShowS)
-> Show MediumLevelILCeilRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCeilRec -> ShowS
showsPrec :: Int -> MediumLevelILCeilRec -> ShowS
$cshow :: MediumLevelILCeilRec -> String
show :: MediumLevelILCeilRec -> String
$cshowList :: [MediumLevelILCeilRec] -> ShowS
showList :: [MediumLevelILCeilRec] -> ShowS
Show, MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
(MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> (MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> Eq MediumLevelILCeilRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
== :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
$c/= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
/= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
Eq, Eq MediumLevelILCeilRec
Eq MediumLevelILCeilRec =>
(MediumLevelILCeilRec -> MediumLevelILCeilRec -> Ordering)
-> (MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> (MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> (MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> (MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool)
-> (MediumLevelILCeilRec
    -> MediumLevelILCeilRec -> MediumLevelILCeilRec)
-> (MediumLevelILCeilRec
    -> MediumLevelILCeilRec -> MediumLevelILCeilRec)
-> Ord MediumLevelILCeilRec
MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
MediumLevelILCeilRec -> MediumLevelILCeilRec -> Ordering
MediumLevelILCeilRec
-> MediumLevelILCeilRec -> MediumLevelILCeilRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Ordering
compare :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Ordering
$c< :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
< :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
$c<= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
<= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
$c> :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
> :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
$c>= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
>= :: MediumLevelILCeilRec -> MediumLevelILCeilRec -> Bool
$cmax :: MediumLevelILCeilRec
-> MediumLevelILCeilRec -> MediumLevelILCeilRec
max :: MediumLevelILCeilRec
-> MediumLevelILCeilRec -> MediumLevelILCeilRec
$cmin :: MediumLevelILCeilRec
-> MediumLevelILCeilRec -> MediumLevelILCeilRec
min :: MediumLevelILCeilRec
-> MediumLevelILCeilRec -> MediumLevelILCeilRec
Ord)

data MediumLevelILFtruncRec = MediumLevelILFtruncRec
  { MediumLevelILFtruncRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILFtruncRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFtruncRec -> ShowS
[MediumLevelILFtruncRec] -> ShowS
MediumLevelILFtruncRec -> String
(Int -> MediumLevelILFtruncRec -> ShowS)
-> (MediumLevelILFtruncRec -> String)
-> ([MediumLevelILFtruncRec] -> ShowS)
-> Show MediumLevelILFtruncRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFtruncRec -> ShowS
showsPrec :: Int -> MediumLevelILFtruncRec -> ShowS
$cshow :: MediumLevelILFtruncRec -> String
show :: MediumLevelILFtruncRec -> String
$cshowList :: [MediumLevelILFtruncRec] -> ShowS
showList :: [MediumLevelILFtruncRec] -> ShowS
Show, MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
(MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> (MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> Eq MediumLevelILFtruncRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
== :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
$c/= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
/= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
Eq, Eq MediumLevelILFtruncRec
Eq MediumLevelILFtruncRec =>
(MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Ordering)
-> (MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> (MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> (MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> (MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool)
-> (MediumLevelILFtruncRec
    -> MediumLevelILFtruncRec -> MediumLevelILFtruncRec)
-> (MediumLevelILFtruncRec
    -> MediumLevelILFtruncRec -> MediumLevelILFtruncRec)
-> Ord MediumLevelILFtruncRec
MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Ordering
MediumLevelILFtruncRec
-> MediumLevelILFtruncRec -> MediumLevelILFtruncRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Ordering
compare :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Ordering
$c< :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
< :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
$c<= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
<= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
$c> :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
> :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
$c>= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
>= :: MediumLevelILFtruncRec -> MediumLevelILFtruncRec -> Bool
$cmax :: MediumLevelILFtruncRec
-> MediumLevelILFtruncRec -> MediumLevelILFtruncRec
max :: MediumLevelILFtruncRec
-> MediumLevelILFtruncRec -> MediumLevelILFtruncRec
$cmin :: MediumLevelILFtruncRec
-> MediumLevelILFtruncRec -> MediumLevelILFtruncRec
min :: MediumLevelILFtruncRec
-> MediumLevelILFtruncRec -> MediumLevelILFtruncRec
Ord)

data MediumLevelILJumpToRec = MediumLevelILJumpToRec
  { MediumLevelILJumpToRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILJumpToRec -> TargetMap
target :: TargetMap,
    MediumLevelILJumpToRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILJumpToRec -> ShowS
[MediumLevelILJumpToRec] -> ShowS
MediumLevelILJumpToRec -> String
(Int -> MediumLevelILJumpToRec -> ShowS)
-> (MediumLevelILJumpToRec -> String)
-> ([MediumLevelILJumpToRec] -> ShowS)
-> Show MediumLevelILJumpToRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILJumpToRec -> ShowS
showsPrec :: Int -> MediumLevelILJumpToRec -> ShowS
$cshow :: MediumLevelILJumpToRec -> String
show :: MediumLevelILJumpToRec -> String
$cshowList :: [MediumLevelILJumpToRec] -> ShowS
showList :: [MediumLevelILJumpToRec] -> ShowS
Show, MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
(MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> (MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> Eq MediumLevelILJumpToRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
== :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
$c/= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
/= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
Eq, Eq MediumLevelILJumpToRec
Eq MediumLevelILJumpToRec =>
(MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Ordering)
-> (MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> (MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> (MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> (MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool)
-> (MediumLevelILJumpToRec
    -> MediumLevelILJumpToRec -> MediumLevelILJumpToRec)
-> (MediumLevelILJumpToRec
    -> MediumLevelILJumpToRec -> MediumLevelILJumpToRec)
-> Ord MediumLevelILJumpToRec
MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Ordering
MediumLevelILJumpToRec
-> MediumLevelILJumpToRec -> MediumLevelILJumpToRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Ordering
compare :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Ordering
$c< :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
< :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
$c<= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
<= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
$c> :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
> :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
$c>= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
>= :: MediumLevelILJumpToRec -> MediumLevelILJumpToRec -> Bool
$cmax :: MediumLevelILJumpToRec
-> MediumLevelILJumpToRec -> MediumLevelILJumpToRec
max :: MediumLevelILJumpToRec
-> MediumLevelILJumpToRec -> MediumLevelILJumpToRec
$cmin :: MediumLevelILJumpToRec
-> MediumLevelILJumpToRec -> MediumLevelILJumpToRec
min :: MediumLevelILJumpToRec
-> MediumLevelILJumpToRec -> MediumLevelILJumpToRec
Ord)

data MediumLevelILIntrinsicSsaRec = MediumLevelILIntrinsicSsaRec
  { MediumLevelILIntrinsicSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILIntrinsicSsaRec -> ILIntrinsic
intrinsic :: ILIntrinsic,
    MediumLevelILIntrinsicSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILIntrinsicSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILIntrinsicSsaRec -> ShowS
[MediumLevelILIntrinsicSsaRec] -> ShowS
MediumLevelILIntrinsicSsaRec -> String
(Int -> MediumLevelILIntrinsicSsaRec -> ShowS)
-> (MediumLevelILIntrinsicSsaRec -> String)
-> ([MediumLevelILIntrinsicSsaRec] -> ShowS)
-> Show MediumLevelILIntrinsicSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILIntrinsicSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILIntrinsicSsaRec -> ShowS
$cshow :: MediumLevelILIntrinsicSsaRec -> String
show :: MediumLevelILIntrinsicSsaRec -> String
$cshowList :: [MediumLevelILIntrinsicSsaRec] -> ShowS
showList :: [MediumLevelILIntrinsicSsaRec] -> ShowS
Show, MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
(MediumLevelILIntrinsicSsaRec
 -> MediumLevelILIntrinsicSsaRec -> Bool)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> Bool)
-> Eq MediumLevelILIntrinsicSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
== :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
$c/= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
/= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
Eq, Eq MediumLevelILIntrinsicSsaRec
Eq MediumLevelILIntrinsicSsaRec =>
(MediumLevelILIntrinsicSsaRec
 -> MediumLevelILIntrinsicSsaRec -> Ordering)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> Bool)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> Bool)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> Bool)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> Bool)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec)
-> (MediumLevelILIntrinsicSsaRec
    -> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec)
-> Ord MediumLevelILIntrinsicSsaRec
MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Ordering
MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Ordering
compare :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Ordering
$c< :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
< :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
$c<= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
<= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
$c> :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
> :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
$c>= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
>= :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> Bool
$cmax :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec
max :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec
$cmin :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec
min :: MediumLevelILIntrinsicSsaRec
-> MediumLevelILIntrinsicSsaRec -> MediumLevelILIntrinsicSsaRec
Ord)

data MediumLevelILIntrinsicRec = MediumLevelILIntrinsicRec
  { MediumLevelILIntrinsicRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILIntrinsicRec -> ILIntrinsic
intrinsic :: ILIntrinsic,
    MediumLevelILIntrinsicRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILIntrinsicRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILIntrinsicRec -> ShowS
[MediumLevelILIntrinsicRec] -> ShowS
MediumLevelILIntrinsicRec -> String
(Int -> MediumLevelILIntrinsicRec -> ShowS)
-> (MediumLevelILIntrinsicRec -> String)
-> ([MediumLevelILIntrinsicRec] -> ShowS)
-> Show MediumLevelILIntrinsicRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILIntrinsicRec -> ShowS
showsPrec :: Int -> MediumLevelILIntrinsicRec -> ShowS
$cshow :: MediumLevelILIntrinsicRec -> String
show :: MediumLevelILIntrinsicRec -> String
$cshowList :: [MediumLevelILIntrinsicRec] -> ShowS
showList :: [MediumLevelILIntrinsicRec] -> ShowS
Show, MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
(MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> (MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> Eq MediumLevelILIntrinsicRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
== :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
$c/= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
/= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
Eq, Eq MediumLevelILIntrinsicRec
Eq MediumLevelILIntrinsicRec =>
(MediumLevelILIntrinsicRec
 -> MediumLevelILIntrinsicRec -> Ordering)
-> (MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> (MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> (MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> (MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool)
-> (MediumLevelILIntrinsicRec
    -> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec)
-> (MediumLevelILIntrinsicRec
    -> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec)
-> Ord MediumLevelILIntrinsicRec
MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Ordering
MediumLevelILIntrinsicRec
-> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Ordering
compare :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Ordering
$c< :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
< :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
$c<= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
<= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
$c> :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
> :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
$c>= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
>= :: MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec -> Bool
$cmax :: MediumLevelILIntrinsicRec
-> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec
max :: MediumLevelILIntrinsicRec
-> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec
$cmin :: MediumLevelILIntrinsicRec
-> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec
min :: MediumLevelILIntrinsicRec
-> MediumLevelILIntrinsicRec -> MediumLevelILIntrinsicRec
Ord)

data MediumLevelILBoolToIntRec = MediumLevelILBoolToIntRec
  { MediumLevelILBoolToIntRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILBoolToIntRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILBoolToIntRec -> ShowS
[MediumLevelILBoolToIntRec] -> ShowS
MediumLevelILBoolToIntRec -> String
(Int -> MediumLevelILBoolToIntRec -> ShowS)
-> (MediumLevelILBoolToIntRec -> String)
-> ([MediumLevelILBoolToIntRec] -> ShowS)
-> Show MediumLevelILBoolToIntRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILBoolToIntRec -> ShowS
showsPrec :: Int -> MediumLevelILBoolToIntRec -> ShowS
$cshow :: MediumLevelILBoolToIntRec -> String
show :: MediumLevelILBoolToIntRec -> String
$cshowList :: [MediumLevelILBoolToIntRec] -> ShowS
showList :: [MediumLevelILBoolToIntRec] -> ShowS
Show, MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
(MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> (MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> Eq MediumLevelILBoolToIntRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
== :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
$c/= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
/= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
Eq, Eq MediumLevelILBoolToIntRec
Eq MediumLevelILBoolToIntRec =>
(MediumLevelILBoolToIntRec
 -> MediumLevelILBoolToIntRec -> Ordering)
-> (MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> (MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> (MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> (MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool)
-> (MediumLevelILBoolToIntRec
    -> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec)
-> (MediumLevelILBoolToIntRec
    -> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec)
-> Ord MediumLevelILBoolToIntRec
MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Ordering
MediumLevelILBoolToIntRec
-> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Ordering
compare :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Ordering
$c< :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
< :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
$c<= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
<= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
$c> :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
> :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
$c>= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
>= :: MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec -> Bool
$cmax :: MediumLevelILBoolToIntRec
-> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec
max :: MediumLevelILBoolToIntRec
-> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec
$cmin :: MediumLevelILBoolToIntRec
-> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec
min :: MediumLevelILBoolToIntRec
-> MediumLevelILBoolToIntRec -> MediumLevelILBoolToIntRec
Ord)

data MediumLevelILVarAliasedRec = MediumLevelILVarAliasedRec
  { MediumLevelILVarAliasedRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILVarAliasedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarAliasedRec -> ShowS
[MediumLevelILVarAliasedRec] -> ShowS
MediumLevelILVarAliasedRec -> String
(Int -> MediumLevelILVarAliasedRec -> ShowS)
-> (MediumLevelILVarAliasedRec -> String)
-> ([MediumLevelILVarAliasedRec] -> ShowS)
-> Show MediumLevelILVarAliasedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarAliasedRec -> ShowS
showsPrec :: Int -> MediumLevelILVarAliasedRec -> ShowS
$cshow :: MediumLevelILVarAliasedRec -> String
show :: MediumLevelILVarAliasedRec -> String
$cshowList :: [MediumLevelILVarAliasedRec] -> ShowS
showList :: [MediumLevelILVarAliasedRec] -> ShowS
Show, MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
(MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> Bool)
-> Eq MediumLevelILVarAliasedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
== :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
$c/= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
/= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
Eq, Eq MediumLevelILVarAliasedRec
Eq MediumLevelILVarAliasedRec =>
(MediumLevelILVarAliasedRec
 -> MediumLevelILVarAliasedRec -> Ordering)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> Bool)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> Bool)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> Bool)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> Bool)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec)
-> (MediumLevelILVarAliasedRec
    -> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec)
-> Ord MediumLevelILVarAliasedRec
MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> Ordering
MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> Ordering
compare :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> Ordering
$c< :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
< :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
$c<= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
<= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
$c> :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
> :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
$c>= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
>= :: MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec -> Bool
$cmax :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec
max :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec
$cmin :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec
min :: MediumLevelILVarAliasedRec
-> MediumLevelILVarAliasedRec -> MediumLevelILVarAliasedRec
Ord)

data MediumLevelILVarAliasedFieldRec = MediumLevelILVarAliasedFieldRec
  { MediumLevelILVarAliasedFieldRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILVarAliasedFieldRec -> Int
offset :: Int,
    MediumLevelILVarAliasedFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarAliasedFieldRec -> ShowS
[MediumLevelILVarAliasedFieldRec] -> ShowS
MediumLevelILVarAliasedFieldRec -> String
(Int -> MediumLevelILVarAliasedFieldRec -> ShowS)
-> (MediumLevelILVarAliasedFieldRec -> String)
-> ([MediumLevelILVarAliasedFieldRec] -> ShowS)
-> Show MediumLevelILVarAliasedFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarAliasedFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarAliasedFieldRec -> ShowS
$cshow :: MediumLevelILVarAliasedFieldRec -> String
show :: MediumLevelILVarAliasedFieldRec -> String
$cshowList :: [MediumLevelILVarAliasedFieldRec] -> ShowS
showList :: [MediumLevelILVarAliasedFieldRec] -> ShowS
Show, MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
(MediumLevelILVarAliasedFieldRec
 -> MediumLevelILVarAliasedFieldRec -> Bool)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec -> Bool)
-> Eq MediumLevelILVarAliasedFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
== :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
$c/= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
/= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
Eq, Eq MediumLevelILVarAliasedFieldRec
Eq MediumLevelILVarAliasedFieldRec =>
(MediumLevelILVarAliasedFieldRec
 -> MediumLevelILVarAliasedFieldRec -> Ordering)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec -> Bool)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec -> Bool)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec -> Bool)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec -> Bool)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec)
-> (MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec
    -> MediumLevelILVarAliasedFieldRec)
-> Ord MediumLevelILVarAliasedFieldRec
MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Ordering
MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Ordering
compare :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Ordering
$c< :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
< :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
$c<= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
<= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
$c> :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
> :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
$c>= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
>= :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec -> Bool
$cmax :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
max :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
$cmin :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
min :: MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
-> MediumLevelILVarAliasedFieldRec
Ord)

data MediumLevelILSetVarAliasedFieldRec = MediumLevelILSetVarAliasedFieldRec
  { MediumLevelILSetVarAliasedFieldRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILSetVarAliasedFieldRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILSetVarAliasedFieldRec -> Int
offset :: Int,
    MediumLevelILSetVarAliasedFieldRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarAliasedFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarAliasedFieldRec -> ShowS
[MediumLevelILSetVarAliasedFieldRec] -> ShowS
MediumLevelILSetVarAliasedFieldRec -> String
(Int -> MediumLevelILSetVarAliasedFieldRec -> ShowS)
-> (MediumLevelILSetVarAliasedFieldRec -> String)
-> ([MediumLevelILSetVarAliasedFieldRec] -> ShowS)
-> Show MediumLevelILSetVarAliasedFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarAliasedFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarAliasedFieldRec -> ShowS
$cshow :: MediumLevelILSetVarAliasedFieldRec -> String
show :: MediumLevelILSetVarAliasedFieldRec -> String
$cshowList :: [MediumLevelILSetVarAliasedFieldRec] -> ShowS
showList :: [MediumLevelILSetVarAliasedFieldRec] -> ShowS
Show, MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
(MediumLevelILSetVarAliasedFieldRec
 -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> Eq MediumLevelILSetVarAliasedFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
== :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
$c/= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
/= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
Eq, Eq MediumLevelILSetVarAliasedFieldRec
Eq MediumLevelILSetVarAliasedFieldRec =>
(MediumLevelILSetVarAliasedFieldRec
 -> MediumLevelILSetVarAliasedFieldRec -> Ordering)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec -> Bool)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec)
-> (MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec
    -> MediumLevelILSetVarAliasedFieldRec)
-> Ord MediumLevelILSetVarAliasedFieldRec
MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Ordering
MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Ordering
compare :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Ordering
$c< :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
< :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
$c<= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
<= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
$c> :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
> :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
$c>= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
>= :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec -> Bool
$cmax :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
max :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
$cmin :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
min :: MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
-> MediumLevelILSetVarAliasedFieldRec
Ord)

data MediumLevelILLoadStructSsaRec = MediumLevelILLoadStructSsaRec
  { MediumLevelILLoadStructSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILLoadStructSsaRec -> Int
offset :: Int,
    MediumLevelILLoadStructSsaRec -> Int
srcMemory :: Int,
    MediumLevelILLoadStructSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLoadStructSsaRec -> ShowS
[MediumLevelILLoadStructSsaRec] -> ShowS
MediumLevelILLoadStructSsaRec -> String
(Int -> MediumLevelILLoadStructSsaRec -> ShowS)
-> (MediumLevelILLoadStructSsaRec -> String)
-> ([MediumLevelILLoadStructSsaRec] -> ShowS)
-> Show MediumLevelILLoadStructSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLoadStructSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILLoadStructSsaRec -> ShowS
$cshow :: MediumLevelILLoadStructSsaRec -> String
show :: MediumLevelILLoadStructSsaRec -> String
$cshowList :: [MediumLevelILLoadStructSsaRec] -> ShowS
showList :: [MediumLevelILLoadStructSsaRec] -> ShowS
Show, MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
(MediumLevelILLoadStructSsaRec
 -> MediumLevelILLoadStructSsaRec -> Bool)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> Bool)
-> Eq MediumLevelILLoadStructSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
== :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
$c/= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
/= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
Eq, Eq MediumLevelILLoadStructSsaRec
Eq MediumLevelILLoadStructSsaRec =>
(MediumLevelILLoadStructSsaRec
 -> MediumLevelILLoadStructSsaRec -> Ordering)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> Bool)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> Bool)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> Bool)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> Bool)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec)
-> (MediumLevelILLoadStructSsaRec
    -> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec)
-> Ord MediumLevelILLoadStructSsaRec
MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Ordering
MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Ordering
compare :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Ordering
$c< :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
< :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
$c<= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
<= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
$c> :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
> :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
$c>= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
>= :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> Bool
$cmax :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec
max :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec
$cmin :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec
min :: MediumLevelILLoadStructSsaRec
-> MediumLevelILLoadStructSsaRec -> MediumLevelILLoadStructSsaRec
Ord)

data MediumLevelILStoreStructSsaRec = MediumLevelILStoreStructSsaRec
  { MediumLevelILStoreStructSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILStoreStructSsaRec -> Int
offset :: Int,
    MediumLevelILStoreStructSsaRec -> Int
destMemory :: Int,
    MediumLevelILStoreStructSsaRec -> Int
srcMemory :: Int,
    MediumLevelILStoreStructSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILStoreStructSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILStoreStructSsaRec -> ShowS
[MediumLevelILStoreStructSsaRec] -> ShowS
MediumLevelILStoreStructSsaRec -> String
(Int -> MediumLevelILStoreStructSsaRec -> ShowS)
-> (MediumLevelILStoreStructSsaRec -> String)
-> ([MediumLevelILStoreStructSsaRec] -> ShowS)
-> Show MediumLevelILStoreStructSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILStoreStructSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILStoreStructSsaRec -> ShowS
$cshow :: MediumLevelILStoreStructSsaRec -> String
show :: MediumLevelILStoreStructSsaRec -> String
$cshowList :: [MediumLevelILStoreStructSsaRec] -> ShowS
showList :: [MediumLevelILStoreStructSsaRec] -> ShowS
Show, MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
(MediumLevelILStoreStructSsaRec
 -> MediumLevelILStoreStructSsaRec -> Bool)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec -> Bool)
-> Eq MediumLevelILStoreStructSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
== :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
$c/= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
/= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
Eq, Eq MediumLevelILStoreStructSsaRec
Eq MediumLevelILStoreStructSsaRec =>
(MediumLevelILStoreStructSsaRec
 -> MediumLevelILStoreStructSsaRec -> Ordering)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec -> Bool)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec -> Bool)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec -> Bool)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec -> Bool)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec)
-> (MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec
    -> MediumLevelILStoreStructSsaRec)
-> Ord MediumLevelILStoreStructSsaRec
MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Ordering
MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> MediumLevelILStoreStructSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Ordering
compare :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Ordering
$c< :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
< :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
$c<= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
<= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
$c> :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
> :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
$c>= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
>= :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> Bool
$cmax :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> MediumLevelILStoreStructSsaRec
max :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> MediumLevelILStoreStructSsaRec
$cmin :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> MediumLevelILStoreStructSsaRec
min :: MediumLevelILStoreStructSsaRec
-> MediumLevelILStoreStructSsaRec -> MediumLevelILStoreStructSsaRec
Ord)

data MediumLevelILFcmpERec = MediumLevelILFcmpERec
  { MediumLevelILFcmpERec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpERec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpERec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpERec -> ShowS
[MediumLevelILFcmpERec] -> ShowS
MediumLevelILFcmpERec -> String
(Int -> MediumLevelILFcmpERec -> ShowS)
-> (MediumLevelILFcmpERec -> String)
-> ([MediumLevelILFcmpERec] -> ShowS)
-> Show MediumLevelILFcmpERec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpERec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpERec -> ShowS
$cshow :: MediumLevelILFcmpERec -> String
show :: MediumLevelILFcmpERec -> String
$cshowList :: [MediumLevelILFcmpERec] -> ShowS
showList :: [MediumLevelILFcmpERec] -> ShowS
Show, MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
(MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> (MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> Eq MediumLevelILFcmpERec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
== :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
$c/= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
/= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
Eq, Eq MediumLevelILFcmpERec
Eq MediumLevelILFcmpERec =>
(MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Ordering)
-> (MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> (MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> (MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> (MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool)
-> (MediumLevelILFcmpERec
    -> MediumLevelILFcmpERec -> MediumLevelILFcmpERec)
-> (MediumLevelILFcmpERec
    -> MediumLevelILFcmpERec -> MediumLevelILFcmpERec)
-> Ord MediumLevelILFcmpERec
MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Ordering
MediumLevelILFcmpERec
-> MediumLevelILFcmpERec -> MediumLevelILFcmpERec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Ordering
compare :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Ordering
$c< :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
< :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
$c<= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
<= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
$c> :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
> :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
$c>= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
>= :: MediumLevelILFcmpERec -> MediumLevelILFcmpERec -> Bool
$cmax :: MediumLevelILFcmpERec
-> MediumLevelILFcmpERec -> MediumLevelILFcmpERec
max :: MediumLevelILFcmpERec
-> MediumLevelILFcmpERec -> MediumLevelILFcmpERec
$cmin :: MediumLevelILFcmpERec
-> MediumLevelILFcmpERec -> MediumLevelILFcmpERec
min :: MediumLevelILFcmpERec
-> MediumLevelILFcmpERec -> MediumLevelILFcmpERec
Ord)

data MediumLevelILFcmpNeRec = MediumLevelILFcmpNeRec
  { MediumLevelILFcmpNeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpNeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpNeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpNeRec -> ShowS
[MediumLevelILFcmpNeRec] -> ShowS
MediumLevelILFcmpNeRec -> String
(Int -> MediumLevelILFcmpNeRec -> ShowS)
-> (MediumLevelILFcmpNeRec -> String)
-> ([MediumLevelILFcmpNeRec] -> ShowS)
-> Show MediumLevelILFcmpNeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpNeRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpNeRec -> ShowS
$cshow :: MediumLevelILFcmpNeRec -> String
show :: MediumLevelILFcmpNeRec -> String
$cshowList :: [MediumLevelILFcmpNeRec] -> ShowS
showList :: [MediumLevelILFcmpNeRec] -> ShowS
Show, MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
(MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> (MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> Eq MediumLevelILFcmpNeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
== :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
$c/= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
/= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
Eq, Eq MediumLevelILFcmpNeRec
Eq MediumLevelILFcmpNeRec =>
(MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Ordering)
-> (MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> (MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> (MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> (MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool)
-> (MediumLevelILFcmpNeRec
    -> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec)
-> (MediumLevelILFcmpNeRec
    -> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec)
-> Ord MediumLevelILFcmpNeRec
MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Ordering
MediumLevelILFcmpNeRec
-> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Ordering
compare :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Ordering
$c< :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
< :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
$c<= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
<= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
$c> :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
> :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
$c>= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
>= :: MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec -> Bool
$cmax :: MediumLevelILFcmpNeRec
-> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec
max :: MediumLevelILFcmpNeRec
-> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec
$cmin :: MediumLevelILFcmpNeRec
-> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec
min :: MediumLevelILFcmpNeRec
-> MediumLevelILFcmpNeRec -> MediumLevelILFcmpNeRec
Ord)

data MediumLevelILFcmpLtRec = MediumLevelILFcmpLtRec
  { MediumLevelILFcmpLtRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpLtRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpLtRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpLtRec -> ShowS
[MediumLevelILFcmpLtRec] -> ShowS
MediumLevelILFcmpLtRec -> String
(Int -> MediumLevelILFcmpLtRec -> ShowS)
-> (MediumLevelILFcmpLtRec -> String)
-> ([MediumLevelILFcmpLtRec] -> ShowS)
-> Show MediumLevelILFcmpLtRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpLtRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpLtRec -> ShowS
$cshow :: MediumLevelILFcmpLtRec -> String
show :: MediumLevelILFcmpLtRec -> String
$cshowList :: [MediumLevelILFcmpLtRec] -> ShowS
showList :: [MediumLevelILFcmpLtRec] -> ShowS
Show, MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
(MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> (MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> Eq MediumLevelILFcmpLtRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
== :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
$c/= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
/= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
Eq, Eq MediumLevelILFcmpLtRec
Eq MediumLevelILFcmpLtRec =>
(MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Ordering)
-> (MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> (MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> (MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> (MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool)
-> (MediumLevelILFcmpLtRec
    -> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec)
-> (MediumLevelILFcmpLtRec
    -> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec)
-> Ord MediumLevelILFcmpLtRec
MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Ordering
MediumLevelILFcmpLtRec
-> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Ordering
compare :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Ordering
$c< :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
< :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
$c<= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
<= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
$c> :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
> :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
$c>= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
>= :: MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec -> Bool
$cmax :: MediumLevelILFcmpLtRec
-> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec
max :: MediumLevelILFcmpLtRec
-> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec
$cmin :: MediumLevelILFcmpLtRec
-> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec
min :: MediumLevelILFcmpLtRec
-> MediumLevelILFcmpLtRec -> MediumLevelILFcmpLtRec
Ord)

data MediumLevelILFcmpLeRec = MediumLevelILFcmpLeRec
  { MediumLevelILFcmpLeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpLeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpLeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpLeRec -> ShowS
[MediumLevelILFcmpLeRec] -> ShowS
MediumLevelILFcmpLeRec -> String
(Int -> MediumLevelILFcmpLeRec -> ShowS)
-> (MediumLevelILFcmpLeRec -> String)
-> ([MediumLevelILFcmpLeRec] -> ShowS)
-> Show MediumLevelILFcmpLeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpLeRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpLeRec -> ShowS
$cshow :: MediumLevelILFcmpLeRec -> String
show :: MediumLevelILFcmpLeRec -> String
$cshowList :: [MediumLevelILFcmpLeRec] -> ShowS
showList :: [MediumLevelILFcmpLeRec] -> ShowS
Show, MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
(MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> (MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> Eq MediumLevelILFcmpLeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
== :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
$c/= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
/= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
Eq, Eq MediumLevelILFcmpLeRec
Eq MediumLevelILFcmpLeRec =>
(MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Ordering)
-> (MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> (MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> (MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> (MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool)
-> (MediumLevelILFcmpLeRec
    -> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec)
-> (MediumLevelILFcmpLeRec
    -> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec)
-> Ord MediumLevelILFcmpLeRec
MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Ordering
MediumLevelILFcmpLeRec
-> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Ordering
compare :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Ordering
$c< :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
< :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
$c<= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
<= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
$c> :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
> :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
$c>= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
>= :: MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec -> Bool
$cmax :: MediumLevelILFcmpLeRec
-> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec
max :: MediumLevelILFcmpLeRec
-> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec
$cmin :: MediumLevelILFcmpLeRec
-> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec
min :: MediumLevelILFcmpLeRec
-> MediumLevelILFcmpLeRec -> MediumLevelILFcmpLeRec
Ord)

data MediumLevelILFcmpGeRec = MediumLevelILFcmpGeRec
  { MediumLevelILFcmpGeRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpGeRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpGeRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpGeRec -> ShowS
[MediumLevelILFcmpGeRec] -> ShowS
MediumLevelILFcmpGeRec -> String
(Int -> MediumLevelILFcmpGeRec -> ShowS)
-> (MediumLevelILFcmpGeRec -> String)
-> ([MediumLevelILFcmpGeRec] -> ShowS)
-> Show MediumLevelILFcmpGeRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpGeRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpGeRec -> ShowS
$cshow :: MediumLevelILFcmpGeRec -> String
show :: MediumLevelILFcmpGeRec -> String
$cshowList :: [MediumLevelILFcmpGeRec] -> ShowS
showList :: [MediumLevelILFcmpGeRec] -> ShowS
Show, MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
(MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> (MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> Eq MediumLevelILFcmpGeRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
== :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
$c/= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
/= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
Eq, Eq MediumLevelILFcmpGeRec
Eq MediumLevelILFcmpGeRec =>
(MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Ordering)
-> (MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> (MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> (MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> (MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool)
-> (MediumLevelILFcmpGeRec
    -> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec)
-> (MediumLevelILFcmpGeRec
    -> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec)
-> Ord MediumLevelILFcmpGeRec
MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Ordering
MediumLevelILFcmpGeRec
-> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Ordering
compare :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Ordering
$c< :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
< :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
$c<= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
<= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
$c> :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
> :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
$c>= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
>= :: MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec -> Bool
$cmax :: MediumLevelILFcmpGeRec
-> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec
max :: MediumLevelILFcmpGeRec
-> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec
$cmin :: MediumLevelILFcmpGeRec
-> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec
min :: MediumLevelILFcmpGeRec
-> MediumLevelILFcmpGeRec -> MediumLevelILFcmpGeRec
Ord)

data MediumLevelILFcmpGtRec = MediumLevelILFcmpGtRec
  { MediumLevelILFcmpGtRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpGtRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpGtRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpGtRec -> ShowS
[MediumLevelILFcmpGtRec] -> ShowS
MediumLevelILFcmpGtRec -> String
(Int -> MediumLevelILFcmpGtRec -> ShowS)
-> (MediumLevelILFcmpGtRec -> String)
-> ([MediumLevelILFcmpGtRec] -> ShowS)
-> Show MediumLevelILFcmpGtRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpGtRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpGtRec -> ShowS
$cshow :: MediumLevelILFcmpGtRec -> String
show :: MediumLevelILFcmpGtRec -> String
$cshowList :: [MediumLevelILFcmpGtRec] -> ShowS
showList :: [MediumLevelILFcmpGtRec] -> ShowS
Show, MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
(MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> (MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> Eq MediumLevelILFcmpGtRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
== :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
$c/= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
/= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
Eq, Eq MediumLevelILFcmpGtRec
Eq MediumLevelILFcmpGtRec =>
(MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Ordering)
-> (MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> (MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> (MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> (MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool)
-> (MediumLevelILFcmpGtRec
    -> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec)
-> (MediumLevelILFcmpGtRec
    -> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec)
-> Ord MediumLevelILFcmpGtRec
MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Ordering
MediumLevelILFcmpGtRec
-> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Ordering
compare :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Ordering
$c< :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
< :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
$c<= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
<= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
$c> :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
> :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
$c>= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
>= :: MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec -> Bool
$cmax :: MediumLevelILFcmpGtRec
-> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec
max :: MediumLevelILFcmpGtRec
-> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec
$cmin :: MediumLevelILFcmpGtRec
-> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec
min :: MediumLevelILFcmpGtRec
-> MediumLevelILFcmpGtRec -> MediumLevelILFcmpGtRec
Ord)

data MediumLevelILFcmpORec = MediumLevelILFcmpORec
  { MediumLevelILFcmpORec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpORec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpORec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpORec -> ShowS
[MediumLevelILFcmpORec] -> ShowS
MediumLevelILFcmpORec -> String
(Int -> MediumLevelILFcmpORec -> ShowS)
-> (MediumLevelILFcmpORec -> String)
-> ([MediumLevelILFcmpORec] -> ShowS)
-> Show MediumLevelILFcmpORec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpORec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpORec -> ShowS
$cshow :: MediumLevelILFcmpORec -> String
show :: MediumLevelILFcmpORec -> String
$cshowList :: [MediumLevelILFcmpORec] -> ShowS
showList :: [MediumLevelILFcmpORec] -> ShowS
Show, MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
(MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> (MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> Eq MediumLevelILFcmpORec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
== :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
$c/= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
/= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
Eq, Eq MediumLevelILFcmpORec
Eq MediumLevelILFcmpORec =>
(MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Ordering)
-> (MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> (MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> (MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> (MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool)
-> (MediumLevelILFcmpORec
    -> MediumLevelILFcmpORec -> MediumLevelILFcmpORec)
-> (MediumLevelILFcmpORec
    -> MediumLevelILFcmpORec -> MediumLevelILFcmpORec)
-> Ord MediumLevelILFcmpORec
MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Ordering
MediumLevelILFcmpORec
-> MediumLevelILFcmpORec -> MediumLevelILFcmpORec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Ordering
compare :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Ordering
$c< :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
< :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
$c<= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
<= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
$c> :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
> :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
$c>= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
>= :: MediumLevelILFcmpORec -> MediumLevelILFcmpORec -> Bool
$cmax :: MediumLevelILFcmpORec
-> MediumLevelILFcmpORec -> MediumLevelILFcmpORec
max :: MediumLevelILFcmpORec
-> MediumLevelILFcmpORec -> MediumLevelILFcmpORec
$cmin :: MediumLevelILFcmpORec
-> MediumLevelILFcmpORec -> MediumLevelILFcmpORec
min :: MediumLevelILFcmpORec
-> MediumLevelILFcmpORec -> MediumLevelILFcmpORec
Ord)

data MediumLevelILFcmpUoRec = MediumLevelILFcmpUoRec
  { MediumLevelILFcmpUoRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpUoRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFcmpUoRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFcmpUoRec -> ShowS
[MediumLevelILFcmpUoRec] -> ShowS
MediumLevelILFcmpUoRec -> String
(Int -> MediumLevelILFcmpUoRec -> ShowS)
-> (MediumLevelILFcmpUoRec -> String)
-> ([MediumLevelILFcmpUoRec] -> ShowS)
-> Show MediumLevelILFcmpUoRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFcmpUoRec -> ShowS
showsPrec :: Int -> MediumLevelILFcmpUoRec -> ShowS
$cshow :: MediumLevelILFcmpUoRec -> String
show :: MediumLevelILFcmpUoRec -> String
$cshowList :: [MediumLevelILFcmpUoRec] -> ShowS
showList :: [MediumLevelILFcmpUoRec] -> ShowS
Show, MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
(MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> (MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> Eq MediumLevelILFcmpUoRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
== :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
$c/= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
/= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
Eq, Eq MediumLevelILFcmpUoRec
Eq MediumLevelILFcmpUoRec =>
(MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Ordering)
-> (MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> (MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> (MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> (MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool)
-> (MediumLevelILFcmpUoRec
    -> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec)
-> (MediumLevelILFcmpUoRec
    -> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec)
-> Ord MediumLevelILFcmpUoRec
MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Ordering
MediumLevelILFcmpUoRec
-> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Ordering
compare :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Ordering
$c< :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
< :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
$c<= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
<= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
$c> :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
> :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
$c>= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
>= :: MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec -> Bool
$cmax :: MediumLevelILFcmpUoRec
-> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec
max :: MediumLevelILFcmpUoRec
-> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec
$cmin :: MediumLevelILFcmpUoRec
-> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec
min :: MediumLevelILFcmpUoRec
-> MediumLevelILFcmpUoRec -> MediumLevelILFcmpUoRec
Ord)

data MediumLevelILFmulRec = MediumLevelILFmulRec
  { MediumLevelILFmulRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFmulRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFmulRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFmulRec -> ShowS
[MediumLevelILFmulRec] -> ShowS
MediumLevelILFmulRec -> String
(Int -> MediumLevelILFmulRec -> ShowS)
-> (MediumLevelILFmulRec -> String)
-> ([MediumLevelILFmulRec] -> ShowS)
-> Show MediumLevelILFmulRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFmulRec -> ShowS
showsPrec :: Int -> MediumLevelILFmulRec -> ShowS
$cshow :: MediumLevelILFmulRec -> String
show :: MediumLevelILFmulRec -> String
$cshowList :: [MediumLevelILFmulRec] -> ShowS
showList :: [MediumLevelILFmulRec] -> ShowS
Show, MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
(MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> (MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> Eq MediumLevelILFmulRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
== :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
$c/= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
/= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
Eq, Eq MediumLevelILFmulRec
Eq MediumLevelILFmulRec =>
(MediumLevelILFmulRec -> MediumLevelILFmulRec -> Ordering)
-> (MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> (MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> (MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> (MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool)
-> (MediumLevelILFmulRec
    -> MediumLevelILFmulRec -> MediumLevelILFmulRec)
-> (MediumLevelILFmulRec
    -> MediumLevelILFmulRec -> MediumLevelILFmulRec)
-> Ord MediumLevelILFmulRec
MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
MediumLevelILFmulRec -> MediumLevelILFmulRec -> Ordering
MediumLevelILFmulRec
-> MediumLevelILFmulRec -> MediumLevelILFmulRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Ordering
compare :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Ordering
$c< :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
< :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
$c<= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
<= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
$c> :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
> :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
$c>= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
>= :: MediumLevelILFmulRec -> MediumLevelILFmulRec -> Bool
$cmax :: MediumLevelILFmulRec
-> MediumLevelILFmulRec -> MediumLevelILFmulRec
max :: MediumLevelILFmulRec
-> MediumLevelILFmulRec -> MediumLevelILFmulRec
$cmin :: MediumLevelILFmulRec
-> MediumLevelILFmulRec -> MediumLevelILFmulRec
min :: MediumLevelILFmulRec
-> MediumLevelILFmulRec -> MediumLevelILFmulRec
Ord)

data MediumLevelILFdivRec = MediumLevelILFdivRec
  { MediumLevelILFdivRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFdivRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFdivRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFdivRec -> ShowS
[MediumLevelILFdivRec] -> ShowS
MediumLevelILFdivRec -> String
(Int -> MediumLevelILFdivRec -> ShowS)
-> (MediumLevelILFdivRec -> String)
-> ([MediumLevelILFdivRec] -> ShowS)
-> Show MediumLevelILFdivRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFdivRec -> ShowS
showsPrec :: Int -> MediumLevelILFdivRec -> ShowS
$cshow :: MediumLevelILFdivRec -> String
show :: MediumLevelILFdivRec -> String
$cshowList :: [MediumLevelILFdivRec] -> ShowS
showList :: [MediumLevelILFdivRec] -> ShowS
Show, MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
(MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> (MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> Eq MediumLevelILFdivRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
== :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
$c/= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
/= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
Eq, Eq MediumLevelILFdivRec
Eq MediumLevelILFdivRec =>
(MediumLevelILFdivRec -> MediumLevelILFdivRec -> Ordering)
-> (MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> (MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> (MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> (MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool)
-> (MediumLevelILFdivRec
    -> MediumLevelILFdivRec -> MediumLevelILFdivRec)
-> (MediumLevelILFdivRec
    -> MediumLevelILFdivRec -> MediumLevelILFdivRec)
-> Ord MediumLevelILFdivRec
MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
MediumLevelILFdivRec -> MediumLevelILFdivRec -> Ordering
MediumLevelILFdivRec
-> MediumLevelILFdivRec -> MediumLevelILFdivRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Ordering
compare :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Ordering
$c< :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
< :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
$c<= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
<= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
$c> :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
> :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
$c>= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
>= :: MediumLevelILFdivRec -> MediumLevelILFdivRec -> Bool
$cmax :: MediumLevelILFdivRec
-> MediumLevelILFdivRec -> MediumLevelILFdivRec
max :: MediumLevelILFdivRec
-> MediumLevelILFdivRec -> MediumLevelILFdivRec
$cmin :: MediumLevelILFdivRec
-> MediumLevelILFdivRec -> MediumLevelILFdivRec
min :: MediumLevelILFdivRec
-> MediumLevelILFdivRec -> MediumLevelILFdivRec
Ord)

data MediumLevelILFsubRec = MediumLevelILFsubRec
  { MediumLevelILFsubRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFsubRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFsubRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFsubRec -> ShowS
[MediumLevelILFsubRec] -> ShowS
MediumLevelILFsubRec -> String
(Int -> MediumLevelILFsubRec -> ShowS)
-> (MediumLevelILFsubRec -> String)
-> ([MediumLevelILFsubRec] -> ShowS)
-> Show MediumLevelILFsubRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFsubRec -> ShowS
showsPrec :: Int -> MediumLevelILFsubRec -> ShowS
$cshow :: MediumLevelILFsubRec -> String
show :: MediumLevelILFsubRec -> String
$cshowList :: [MediumLevelILFsubRec] -> ShowS
showList :: [MediumLevelILFsubRec] -> ShowS
Show, MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
(MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> (MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> Eq MediumLevelILFsubRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
== :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
$c/= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
/= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
Eq, Eq MediumLevelILFsubRec
Eq MediumLevelILFsubRec =>
(MediumLevelILFsubRec -> MediumLevelILFsubRec -> Ordering)
-> (MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> (MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> (MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> (MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool)
-> (MediumLevelILFsubRec
    -> MediumLevelILFsubRec -> MediumLevelILFsubRec)
-> (MediumLevelILFsubRec
    -> MediumLevelILFsubRec -> MediumLevelILFsubRec)
-> Ord MediumLevelILFsubRec
MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
MediumLevelILFsubRec -> MediumLevelILFsubRec -> Ordering
MediumLevelILFsubRec
-> MediumLevelILFsubRec -> MediumLevelILFsubRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Ordering
compare :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Ordering
$c< :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
< :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
$c<= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
<= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
$c> :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
> :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
$c>= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
>= :: MediumLevelILFsubRec -> MediumLevelILFsubRec -> Bool
$cmax :: MediumLevelILFsubRec
-> MediumLevelILFsubRec -> MediumLevelILFsubRec
max :: MediumLevelILFsubRec
-> MediumLevelILFsubRec -> MediumLevelILFsubRec
$cmin :: MediumLevelILFsubRec
-> MediumLevelILFsubRec -> MediumLevelILFsubRec
min :: MediumLevelILFsubRec
-> MediumLevelILFsubRec -> MediumLevelILFsubRec
Ord)

data MediumLevelILFaddRec = MediumLevelILFaddRec
  { MediumLevelILFaddRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILFaddRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILFaddRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFaddRec -> ShowS
[MediumLevelILFaddRec] -> ShowS
MediumLevelILFaddRec -> String
(Int -> MediumLevelILFaddRec -> ShowS)
-> (MediumLevelILFaddRec -> String)
-> ([MediumLevelILFaddRec] -> ShowS)
-> Show MediumLevelILFaddRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFaddRec -> ShowS
showsPrec :: Int -> MediumLevelILFaddRec -> ShowS
$cshow :: MediumLevelILFaddRec -> String
show :: MediumLevelILFaddRec -> String
$cshowList :: [MediumLevelILFaddRec] -> ShowS
showList :: [MediumLevelILFaddRec] -> ShowS
Show, MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
(MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> (MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> Eq MediumLevelILFaddRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
== :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
$c/= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
/= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
Eq, Eq MediumLevelILFaddRec
Eq MediumLevelILFaddRec =>
(MediumLevelILFaddRec -> MediumLevelILFaddRec -> Ordering)
-> (MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> (MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> (MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> (MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool)
-> (MediumLevelILFaddRec
    -> MediumLevelILFaddRec -> MediumLevelILFaddRec)
-> (MediumLevelILFaddRec
    -> MediumLevelILFaddRec -> MediumLevelILFaddRec)
-> Ord MediumLevelILFaddRec
MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
MediumLevelILFaddRec -> MediumLevelILFaddRec -> Ordering
MediumLevelILFaddRec
-> MediumLevelILFaddRec -> MediumLevelILFaddRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Ordering
compare :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Ordering
$c< :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
< :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
$c<= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
<= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
$c> :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
> :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
$c>= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
>= :: MediumLevelILFaddRec -> MediumLevelILFaddRec -> Bool
$cmax :: MediumLevelILFaddRec
-> MediumLevelILFaddRec -> MediumLevelILFaddRec
max :: MediumLevelILFaddRec
-> MediumLevelILFaddRec -> MediumLevelILFaddRec
$cmin :: MediumLevelILFaddRec
-> MediumLevelILFaddRec -> MediumLevelILFaddRec
min :: MediumLevelILFaddRec
-> MediumLevelILFaddRec -> MediumLevelILFaddRec
Ord)

data MediumLevelILTestBitRec = MediumLevelILTestBitRec
  { MediumLevelILTestBitRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILTestBitRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILTestBitRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTestBitRec -> ShowS
[MediumLevelILTestBitRec] -> ShowS
MediumLevelILTestBitRec -> String
(Int -> MediumLevelILTestBitRec -> ShowS)
-> (MediumLevelILTestBitRec -> String)
-> ([MediumLevelILTestBitRec] -> ShowS)
-> Show MediumLevelILTestBitRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTestBitRec -> ShowS
showsPrec :: Int -> MediumLevelILTestBitRec -> ShowS
$cshow :: MediumLevelILTestBitRec -> String
show :: MediumLevelILTestBitRec -> String
$cshowList :: [MediumLevelILTestBitRec] -> ShowS
showList :: [MediumLevelILTestBitRec] -> ShowS
Show, MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
(MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> (MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> Eq MediumLevelILTestBitRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
== :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
$c/= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
/= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
Eq, Eq MediumLevelILTestBitRec
Eq MediumLevelILTestBitRec =>
(MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Ordering)
-> (MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> (MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> (MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> (MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool)
-> (MediumLevelILTestBitRec
    -> MediumLevelILTestBitRec -> MediumLevelILTestBitRec)
-> (MediumLevelILTestBitRec
    -> MediumLevelILTestBitRec -> MediumLevelILTestBitRec)
-> Ord MediumLevelILTestBitRec
MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Ordering
MediumLevelILTestBitRec
-> MediumLevelILTestBitRec -> MediumLevelILTestBitRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Ordering
compare :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Ordering
$c< :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
< :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
$c<= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
<= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
$c> :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
> :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
$c>= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
>= :: MediumLevelILTestBitRec -> MediumLevelILTestBitRec -> Bool
$cmax :: MediumLevelILTestBitRec
-> MediumLevelILTestBitRec -> MediumLevelILTestBitRec
max :: MediumLevelILTestBitRec
-> MediumLevelILTestBitRec -> MediumLevelILTestBitRec
$cmin :: MediumLevelILTestBitRec
-> MediumLevelILTestBitRec -> MediumLevelILTestBitRec
min :: MediumLevelILTestBitRec
-> MediumLevelILTestBitRec -> MediumLevelILTestBitRec
Ord)

data MediumLevelILConstDataRec = MediumLevelILConstDataRec
  { MediumLevelILConstDataRec -> BNDataBufferPtr
constant :: BNDataBufferPtr,
    MediumLevelILConstDataRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILConstDataRec -> ShowS
[MediumLevelILConstDataRec] -> ShowS
MediumLevelILConstDataRec -> String
(Int -> MediumLevelILConstDataRec -> ShowS)
-> (MediumLevelILConstDataRec -> String)
-> ([MediumLevelILConstDataRec] -> ShowS)
-> Show MediumLevelILConstDataRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILConstDataRec -> ShowS
showsPrec :: Int -> MediumLevelILConstDataRec -> ShowS
$cshow :: MediumLevelILConstDataRec -> String
show :: MediumLevelILConstDataRec -> String
$cshowList :: [MediumLevelILConstDataRec] -> ShowS
showList :: [MediumLevelILConstDataRec] -> ShowS
Show, MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
(MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> (MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> Eq MediumLevelILConstDataRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
== :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
$c/= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
/= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
Eq, Eq MediumLevelILConstDataRec
Eq MediumLevelILConstDataRec =>
(MediumLevelILConstDataRec
 -> MediumLevelILConstDataRec -> Ordering)
-> (MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> (MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> (MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> (MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool)
-> (MediumLevelILConstDataRec
    -> MediumLevelILConstDataRec -> MediumLevelILConstDataRec)
-> (MediumLevelILConstDataRec
    -> MediumLevelILConstDataRec -> MediumLevelILConstDataRec)
-> Ord MediumLevelILConstDataRec
MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Ordering
MediumLevelILConstDataRec
-> MediumLevelILConstDataRec -> MediumLevelILConstDataRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Ordering
compare :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Ordering
$c< :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
< :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
$c<= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
<= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
$c> :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
> :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
$c>= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
>= :: MediumLevelILConstDataRec -> MediumLevelILConstDataRec -> Bool
$cmax :: MediumLevelILConstDataRec
-> MediumLevelILConstDataRec -> MediumLevelILConstDataRec
max :: MediumLevelILConstDataRec
-> MediumLevelILConstDataRec -> MediumLevelILConstDataRec
$cmin :: MediumLevelILConstDataRec
-> MediumLevelILConstDataRec -> MediumLevelILConstDataRec
min :: MediumLevelILConstDataRec
-> MediumLevelILConstDataRec -> MediumLevelILConstDataRec
Ord)

data MediumLevelILFloatConstRec = MediumLevelILFloatConstRec
  { MediumLevelILFloatConstRec -> Double
constant :: Double,
    MediumLevelILFloatConstRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFloatConstRec -> ShowS
[MediumLevelILFloatConstRec] -> ShowS
MediumLevelILFloatConstRec -> String
(Int -> MediumLevelILFloatConstRec -> ShowS)
-> (MediumLevelILFloatConstRec -> String)
-> ([MediumLevelILFloatConstRec] -> ShowS)
-> Show MediumLevelILFloatConstRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFloatConstRec -> ShowS
showsPrec :: Int -> MediumLevelILFloatConstRec -> ShowS
$cshow :: MediumLevelILFloatConstRec -> String
show :: MediumLevelILFloatConstRec -> String
$cshowList :: [MediumLevelILFloatConstRec] -> ShowS
showList :: [MediumLevelILFloatConstRec] -> ShowS
Show, MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
(MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> Bool)
-> Eq MediumLevelILFloatConstRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
== :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
$c/= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
/= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
Eq, Eq MediumLevelILFloatConstRec
Eq MediumLevelILFloatConstRec =>
(MediumLevelILFloatConstRec
 -> MediumLevelILFloatConstRec -> Ordering)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> Bool)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> Bool)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> Bool)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> Bool)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec)
-> (MediumLevelILFloatConstRec
    -> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec)
-> Ord MediumLevelILFloatConstRec
MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> Ordering
MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> Ordering
compare :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> Ordering
$c< :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
< :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
$c<= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
<= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
$c> :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
> :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
$c>= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
>= :: MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec -> Bool
$cmax :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec
max :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec
$cmin :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec
min :: MediumLevelILFloatConstRec
-> MediumLevelILFloatConstRec -> MediumLevelILFloatConstRec
Ord)

data MediumLevelILAdcRec = MediumLevelILAdcRec
  { MediumLevelILAdcRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILAdcRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILAdcRec -> MediumLevelILSSAInstruction
carry :: MediumLevelILSSAInstruction,
    MediumLevelILAdcRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAdcRec -> ShowS
[MediumLevelILAdcRec] -> ShowS
MediumLevelILAdcRec -> String
(Int -> MediumLevelILAdcRec -> ShowS)
-> (MediumLevelILAdcRec -> String)
-> ([MediumLevelILAdcRec] -> ShowS)
-> Show MediumLevelILAdcRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAdcRec -> ShowS
showsPrec :: Int -> MediumLevelILAdcRec -> ShowS
$cshow :: MediumLevelILAdcRec -> String
show :: MediumLevelILAdcRec -> String
$cshowList :: [MediumLevelILAdcRec] -> ShowS
showList :: [MediumLevelILAdcRec] -> ShowS
Show, MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
(MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> (MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> Eq MediumLevelILAdcRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
== :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
$c/= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
/= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
Eq, Eq MediumLevelILAdcRec
Eq MediumLevelILAdcRec =>
(MediumLevelILAdcRec -> MediumLevelILAdcRec -> Ordering)
-> (MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> (MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> (MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> (MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool)
-> (MediumLevelILAdcRec
    -> MediumLevelILAdcRec -> MediumLevelILAdcRec)
-> (MediumLevelILAdcRec
    -> MediumLevelILAdcRec -> MediumLevelILAdcRec)
-> Ord MediumLevelILAdcRec
MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
MediumLevelILAdcRec -> MediumLevelILAdcRec -> Ordering
MediumLevelILAdcRec -> MediumLevelILAdcRec -> MediumLevelILAdcRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Ordering
compare :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Ordering
$c< :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
< :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
$c<= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
<= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
$c> :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
> :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
$c>= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
>= :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> Bool
$cmax :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> MediumLevelILAdcRec
max :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> MediumLevelILAdcRec
$cmin :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> MediumLevelILAdcRec
min :: MediumLevelILAdcRec -> MediumLevelILAdcRec -> MediumLevelILAdcRec
Ord)

data MediumLevelILSbbRec = MediumLevelILSbbRec
  { MediumLevelILSbbRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILSbbRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILSbbRec -> MediumLevelILSSAInstruction
carry :: MediumLevelILSSAInstruction,
    MediumLevelILSbbRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSbbRec -> ShowS
[MediumLevelILSbbRec] -> ShowS
MediumLevelILSbbRec -> String
(Int -> MediumLevelILSbbRec -> ShowS)
-> (MediumLevelILSbbRec -> String)
-> ([MediumLevelILSbbRec] -> ShowS)
-> Show MediumLevelILSbbRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSbbRec -> ShowS
showsPrec :: Int -> MediumLevelILSbbRec -> ShowS
$cshow :: MediumLevelILSbbRec -> String
show :: MediumLevelILSbbRec -> String
$cshowList :: [MediumLevelILSbbRec] -> ShowS
showList :: [MediumLevelILSbbRec] -> ShowS
Show, MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
(MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> (MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> Eq MediumLevelILSbbRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
== :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
$c/= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
/= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
Eq, Eq MediumLevelILSbbRec
Eq MediumLevelILSbbRec =>
(MediumLevelILSbbRec -> MediumLevelILSbbRec -> Ordering)
-> (MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> (MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> (MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> (MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool)
-> (MediumLevelILSbbRec
    -> MediumLevelILSbbRec -> MediumLevelILSbbRec)
-> (MediumLevelILSbbRec
    -> MediumLevelILSbbRec -> MediumLevelILSbbRec)
-> Ord MediumLevelILSbbRec
MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
MediumLevelILSbbRec -> MediumLevelILSbbRec -> Ordering
MediumLevelILSbbRec -> MediumLevelILSbbRec -> MediumLevelILSbbRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Ordering
compare :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Ordering
$c< :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
< :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
$c<= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
<= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
$c> :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
> :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
$c>= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
>= :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> Bool
$cmax :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> MediumLevelILSbbRec
max :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> MediumLevelILSbbRec
$cmin :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> MediumLevelILSbbRec
min :: MediumLevelILSbbRec -> MediumLevelILSbbRec -> MediumLevelILSbbRec
Ord)

data MediumLevelILRlcRec = MediumLevelILRlcRec
  { MediumLevelILRlcRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILRlcRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILRlcRec -> MediumLevelILSSAInstruction
carry :: MediumLevelILSSAInstruction,
    MediumLevelILRlcRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRlcRec -> ShowS
[MediumLevelILRlcRec] -> ShowS
MediumLevelILRlcRec -> String
(Int -> MediumLevelILRlcRec -> ShowS)
-> (MediumLevelILRlcRec -> String)
-> ([MediumLevelILRlcRec] -> ShowS)
-> Show MediumLevelILRlcRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRlcRec -> ShowS
showsPrec :: Int -> MediumLevelILRlcRec -> ShowS
$cshow :: MediumLevelILRlcRec -> String
show :: MediumLevelILRlcRec -> String
$cshowList :: [MediumLevelILRlcRec] -> ShowS
showList :: [MediumLevelILRlcRec] -> ShowS
Show, MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
(MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> (MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> Eq MediumLevelILRlcRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
== :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
$c/= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
/= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
Eq, Eq MediumLevelILRlcRec
Eq MediumLevelILRlcRec =>
(MediumLevelILRlcRec -> MediumLevelILRlcRec -> Ordering)
-> (MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> (MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> (MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> (MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool)
-> (MediumLevelILRlcRec
    -> MediumLevelILRlcRec -> MediumLevelILRlcRec)
-> (MediumLevelILRlcRec
    -> MediumLevelILRlcRec -> MediumLevelILRlcRec)
-> Ord MediumLevelILRlcRec
MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
MediumLevelILRlcRec -> MediumLevelILRlcRec -> Ordering
MediumLevelILRlcRec -> MediumLevelILRlcRec -> MediumLevelILRlcRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Ordering
compare :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Ordering
$c< :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
< :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
$c<= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
<= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
$c> :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
> :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
$c>= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
>= :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> Bool
$cmax :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> MediumLevelILRlcRec
max :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> MediumLevelILRlcRec
$cmin :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> MediumLevelILRlcRec
min :: MediumLevelILRlcRec -> MediumLevelILRlcRec -> MediumLevelILRlcRec
Ord)

data MediumLevelILRrcRec = MediumLevelILRrcRec
  { MediumLevelILRrcRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILRrcRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILRrcRec -> MediumLevelILSSAInstruction
carry :: MediumLevelILSSAInstruction,
    MediumLevelILRrcRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRrcRec -> ShowS
[MediumLevelILRrcRec] -> ShowS
MediumLevelILRrcRec -> String
(Int -> MediumLevelILRrcRec -> ShowS)
-> (MediumLevelILRrcRec -> String)
-> ([MediumLevelILRrcRec] -> ShowS)
-> Show MediumLevelILRrcRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRrcRec -> ShowS
showsPrec :: Int -> MediumLevelILRrcRec -> ShowS
$cshow :: MediumLevelILRrcRec -> String
show :: MediumLevelILRrcRec -> String
$cshowList :: [MediumLevelILRrcRec] -> ShowS
showList :: [MediumLevelILRrcRec] -> ShowS
Show, MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
(MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> (MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> Eq MediumLevelILRrcRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
== :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
$c/= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
/= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
Eq, Eq MediumLevelILRrcRec
Eq MediumLevelILRrcRec =>
(MediumLevelILRrcRec -> MediumLevelILRrcRec -> Ordering)
-> (MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> (MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> (MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> (MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool)
-> (MediumLevelILRrcRec
    -> MediumLevelILRrcRec -> MediumLevelILRrcRec)
-> (MediumLevelILRrcRec
    -> MediumLevelILRrcRec -> MediumLevelILRrcRec)
-> Ord MediumLevelILRrcRec
MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
MediumLevelILRrcRec -> MediumLevelILRrcRec -> Ordering
MediumLevelILRrcRec -> MediumLevelILRrcRec -> MediumLevelILRrcRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Ordering
compare :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Ordering
$c< :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
< :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
$c<= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
<= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
$c> :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
> :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
$c>= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
>= :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> Bool
$cmax :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> MediumLevelILRrcRec
max :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> MediumLevelILRrcRec
$cmin :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> MediumLevelILRrcRec
min :: MediumLevelILRrcRec -> MediumLevelILRrcRec -> MediumLevelILRrcRec
Ord)

data MediumLevelILSetVarRec = MediumLevelILSetVarRec
  { MediumLevelILSetVarRec -> BNVariable
dest :: BNVariable,
    MediumLevelILSetVarRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarRec -> ShowS
[MediumLevelILSetVarRec] -> ShowS
MediumLevelILSetVarRec -> String
(Int -> MediumLevelILSetVarRec -> ShowS)
-> (MediumLevelILSetVarRec -> String)
-> ([MediumLevelILSetVarRec] -> ShowS)
-> Show MediumLevelILSetVarRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarRec -> ShowS
$cshow :: MediumLevelILSetVarRec -> String
show :: MediumLevelILSetVarRec -> String
$cshowList :: [MediumLevelILSetVarRec] -> ShowS
showList :: [MediumLevelILSetVarRec] -> ShowS
Show, MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
(MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> (MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> Eq MediumLevelILSetVarRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
== :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
$c/= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
/= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
Eq, Eq MediumLevelILSetVarRec
Eq MediumLevelILSetVarRec =>
(MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Ordering)
-> (MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> (MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> (MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> (MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool)
-> (MediumLevelILSetVarRec
    -> MediumLevelILSetVarRec -> MediumLevelILSetVarRec)
-> (MediumLevelILSetVarRec
    -> MediumLevelILSetVarRec -> MediumLevelILSetVarRec)
-> Ord MediumLevelILSetVarRec
MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Ordering
MediumLevelILSetVarRec
-> MediumLevelILSetVarRec -> MediumLevelILSetVarRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Ordering
compare :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Ordering
$c< :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
< :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
$c<= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
<= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
$c> :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
> :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
$c>= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
>= :: MediumLevelILSetVarRec -> MediumLevelILSetVarRec -> Bool
$cmax :: MediumLevelILSetVarRec
-> MediumLevelILSetVarRec -> MediumLevelILSetVarRec
max :: MediumLevelILSetVarRec
-> MediumLevelILSetVarRec -> MediumLevelILSetVarRec
$cmin :: MediumLevelILSetVarRec
-> MediumLevelILSetVarRec -> MediumLevelILSetVarRec
min :: MediumLevelILSetVarRec
-> MediumLevelILSetVarRec -> MediumLevelILSetVarRec
Ord)

data MediumLevelILSetVarFieldRec = MediumLevelILSetVarFieldRec
  { MediumLevelILSetVarFieldRec -> BNVariable
dest :: BNVariable,
    MediumLevelILSetVarFieldRec -> Int
offset :: Int,
    MediumLevelILSetVarFieldRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarFieldRec -> ShowS
[MediumLevelILSetVarFieldRec] -> ShowS
MediumLevelILSetVarFieldRec -> String
(Int -> MediumLevelILSetVarFieldRec -> ShowS)
-> (MediumLevelILSetVarFieldRec -> String)
-> ([MediumLevelILSetVarFieldRec] -> ShowS)
-> Show MediumLevelILSetVarFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarFieldRec -> ShowS
$cshow :: MediumLevelILSetVarFieldRec -> String
show :: MediumLevelILSetVarFieldRec -> String
$cshowList :: [MediumLevelILSetVarFieldRec] -> ShowS
showList :: [MediumLevelILSetVarFieldRec] -> ShowS
Show, MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
(MediumLevelILSetVarFieldRec
 -> MediumLevelILSetVarFieldRec -> Bool)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> Bool)
-> Eq MediumLevelILSetVarFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
== :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
$c/= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
/= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
Eq, Eq MediumLevelILSetVarFieldRec
Eq MediumLevelILSetVarFieldRec =>
(MediumLevelILSetVarFieldRec
 -> MediumLevelILSetVarFieldRec -> Ordering)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> Bool)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> Bool)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> Bool)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> Bool)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec)
-> (MediumLevelILSetVarFieldRec
    -> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec)
-> Ord MediumLevelILSetVarFieldRec
MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> Ordering
MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> Ordering
compare :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> Ordering
$c< :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
< :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
$c<= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
<= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
$c> :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
> :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
$c>= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
>= :: MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec -> Bool
$cmax :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec
max :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec
$cmin :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec
min :: MediumLevelILSetVarFieldRec
-> MediumLevelILSetVarFieldRec -> MediumLevelILSetVarFieldRec
Ord)

data MediumLevelILSetVarSplitRec = MediumLevelILSetVarSplitRec
  { MediumLevelILSetVarSplitRec -> BNVariable
high :: BNVariable,
    MediumLevelILSetVarSplitRec -> BNVariable
low :: BNVariable,
    MediumLevelILSetVarSplitRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarSplitRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarSplitRec -> ShowS
[MediumLevelILSetVarSplitRec] -> ShowS
MediumLevelILSetVarSplitRec -> String
(Int -> MediumLevelILSetVarSplitRec -> ShowS)
-> (MediumLevelILSetVarSplitRec -> String)
-> ([MediumLevelILSetVarSplitRec] -> ShowS)
-> Show MediumLevelILSetVarSplitRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarSplitRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarSplitRec -> ShowS
$cshow :: MediumLevelILSetVarSplitRec -> String
show :: MediumLevelILSetVarSplitRec -> String
$cshowList :: [MediumLevelILSetVarSplitRec] -> ShowS
showList :: [MediumLevelILSetVarSplitRec] -> ShowS
Show, MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
(MediumLevelILSetVarSplitRec
 -> MediumLevelILSetVarSplitRec -> Bool)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> Bool)
-> Eq MediumLevelILSetVarSplitRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
== :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
$c/= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
/= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
Eq, Eq MediumLevelILSetVarSplitRec
Eq MediumLevelILSetVarSplitRec =>
(MediumLevelILSetVarSplitRec
 -> MediumLevelILSetVarSplitRec -> Ordering)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> Bool)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> Bool)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> Bool)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> Bool)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec)
-> (MediumLevelILSetVarSplitRec
    -> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec)
-> Ord MediumLevelILSetVarSplitRec
MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> Ordering
MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> Ordering
compare :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> Ordering
$c< :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
< :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
$c<= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
<= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
$c> :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
> :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
$c>= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
>= :: MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec -> Bool
$cmax :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec
max :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec
$cmin :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec
min :: MediumLevelILSetVarSplitRec
-> MediumLevelILSetVarSplitRec -> MediumLevelILSetVarSplitRec
Ord)

data MediumLevelILAssertRec = MediumLevelILAssertRec
  { MediumLevelILAssertRec -> BNVariable
src :: BNVariable,
    MediumLevelILAssertRec -> BNPossibleValueSet
constraint :: BNPossibleValueSet,
    MediumLevelILAssertRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAssertRec -> ShowS
[MediumLevelILAssertRec] -> ShowS
MediumLevelILAssertRec -> String
(Int -> MediumLevelILAssertRec -> ShowS)
-> (MediumLevelILAssertRec -> String)
-> ([MediumLevelILAssertRec] -> ShowS)
-> Show MediumLevelILAssertRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAssertRec -> ShowS
showsPrec :: Int -> MediumLevelILAssertRec -> ShowS
$cshow :: MediumLevelILAssertRec -> String
show :: MediumLevelILAssertRec -> String
$cshowList :: [MediumLevelILAssertRec] -> ShowS
showList :: [MediumLevelILAssertRec] -> ShowS
Show, MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
(MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> (MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> Eq MediumLevelILAssertRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
== :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
$c/= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
/= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
Eq, Eq MediumLevelILAssertRec
Eq MediumLevelILAssertRec =>
(MediumLevelILAssertRec -> MediumLevelILAssertRec -> Ordering)
-> (MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> (MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> (MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> (MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool)
-> (MediumLevelILAssertRec
    -> MediumLevelILAssertRec -> MediumLevelILAssertRec)
-> (MediumLevelILAssertRec
    -> MediumLevelILAssertRec -> MediumLevelILAssertRec)
-> Ord MediumLevelILAssertRec
MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
MediumLevelILAssertRec -> MediumLevelILAssertRec -> Ordering
MediumLevelILAssertRec
-> MediumLevelILAssertRec -> MediumLevelILAssertRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Ordering
compare :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Ordering
$c< :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
< :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
$c<= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
<= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
$c> :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
> :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
$c>= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
>= :: MediumLevelILAssertRec -> MediumLevelILAssertRec -> Bool
$cmax :: MediumLevelILAssertRec
-> MediumLevelILAssertRec -> MediumLevelILAssertRec
max :: MediumLevelILAssertRec
-> MediumLevelILAssertRec -> MediumLevelILAssertRec
$cmin :: MediumLevelILAssertRec
-> MediumLevelILAssertRec -> MediumLevelILAssertRec
min :: MediumLevelILAssertRec
-> MediumLevelILAssertRec -> MediumLevelILAssertRec
Ord)

data MediumLevelILAssertSsaRec = MediumLevelILAssertSsaRec
  { MediumLevelILAssertSsaRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILAssertSsaRec -> BNPossibleValueSet
constraint :: BNPossibleValueSet,
    MediumLevelILAssertSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAssertSsaRec -> ShowS
[MediumLevelILAssertSsaRec] -> ShowS
MediumLevelILAssertSsaRec -> String
(Int -> MediumLevelILAssertSsaRec -> ShowS)
-> (MediumLevelILAssertSsaRec -> String)
-> ([MediumLevelILAssertSsaRec] -> ShowS)
-> Show MediumLevelILAssertSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAssertSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILAssertSsaRec -> ShowS
$cshow :: MediumLevelILAssertSsaRec -> String
show :: MediumLevelILAssertSsaRec -> String
$cshowList :: [MediumLevelILAssertSsaRec] -> ShowS
showList :: [MediumLevelILAssertSsaRec] -> ShowS
Show, MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
(MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> (MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> Eq MediumLevelILAssertSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
== :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
$c/= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
/= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
Eq, Eq MediumLevelILAssertSsaRec
Eq MediumLevelILAssertSsaRec =>
(MediumLevelILAssertSsaRec
 -> MediumLevelILAssertSsaRec -> Ordering)
-> (MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> (MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> (MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> (MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool)
-> (MediumLevelILAssertSsaRec
    -> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec)
-> (MediumLevelILAssertSsaRec
    -> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec)
-> Ord MediumLevelILAssertSsaRec
MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Ordering
MediumLevelILAssertSsaRec
-> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Ordering
compare :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Ordering
$c< :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
< :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
$c<= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
<= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
$c> :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
> :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
$c>= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
>= :: MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec -> Bool
$cmax :: MediumLevelILAssertSsaRec
-> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec
max :: MediumLevelILAssertSsaRec
-> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec
$cmin :: MediumLevelILAssertSsaRec
-> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec
min :: MediumLevelILAssertSsaRec
-> MediumLevelILAssertSsaRec -> MediumLevelILAssertSsaRec
Ord)

data MediumLevelILForceVerRec = MediumLevelILForceVerRec
  { MediumLevelILForceVerRec -> BNVariable
dest :: BNVariable,
    MediumLevelILForceVerRec -> BNVariable
src :: BNVariable,
    MediumLevelILForceVerRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILForceVerRec -> ShowS
[MediumLevelILForceVerRec] -> ShowS
MediumLevelILForceVerRec -> String
(Int -> MediumLevelILForceVerRec -> ShowS)
-> (MediumLevelILForceVerRec -> String)
-> ([MediumLevelILForceVerRec] -> ShowS)
-> Show MediumLevelILForceVerRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILForceVerRec -> ShowS
showsPrec :: Int -> MediumLevelILForceVerRec -> ShowS
$cshow :: MediumLevelILForceVerRec -> String
show :: MediumLevelILForceVerRec -> String
$cshowList :: [MediumLevelILForceVerRec] -> ShowS
showList :: [MediumLevelILForceVerRec] -> ShowS
Show, MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
(MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> (MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> Eq MediumLevelILForceVerRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
== :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
$c/= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
/= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
Eq, Eq MediumLevelILForceVerRec
Eq MediumLevelILForceVerRec =>
(MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Ordering)
-> (MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> (MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> (MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> (MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool)
-> (MediumLevelILForceVerRec
    -> MediumLevelILForceVerRec -> MediumLevelILForceVerRec)
-> (MediumLevelILForceVerRec
    -> MediumLevelILForceVerRec -> MediumLevelILForceVerRec)
-> Ord MediumLevelILForceVerRec
MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Ordering
MediumLevelILForceVerRec
-> MediumLevelILForceVerRec -> MediumLevelILForceVerRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Ordering
compare :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Ordering
$c< :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
< :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
$c<= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
<= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
$c> :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
> :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
$c>= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
>= :: MediumLevelILForceVerRec -> MediumLevelILForceVerRec -> Bool
$cmax :: MediumLevelILForceVerRec
-> MediumLevelILForceVerRec -> MediumLevelILForceVerRec
max :: MediumLevelILForceVerRec
-> MediumLevelILForceVerRec -> MediumLevelILForceVerRec
$cmin :: MediumLevelILForceVerRec
-> MediumLevelILForceVerRec -> MediumLevelILForceVerRec
min :: MediumLevelILForceVerRec
-> MediumLevelILForceVerRec -> MediumLevelILForceVerRec
Ord)

data MediumLevelILForceVerSsaRec = MediumLevelILForceVerSsaRec
  { MediumLevelILForceVerSsaRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILForceVerSsaRec -> BNSSAVariable
src :: BNSSAVariable,
    MediumLevelILForceVerSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILForceVerSsaRec -> ShowS
[MediumLevelILForceVerSsaRec] -> ShowS
MediumLevelILForceVerSsaRec -> String
(Int -> MediumLevelILForceVerSsaRec -> ShowS)
-> (MediumLevelILForceVerSsaRec -> String)
-> ([MediumLevelILForceVerSsaRec] -> ShowS)
-> Show MediumLevelILForceVerSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILForceVerSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILForceVerSsaRec -> ShowS
$cshow :: MediumLevelILForceVerSsaRec -> String
show :: MediumLevelILForceVerSsaRec -> String
$cshowList :: [MediumLevelILForceVerSsaRec] -> ShowS
showList :: [MediumLevelILForceVerSsaRec] -> ShowS
Show, MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
(MediumLevelILForceVerSsaRec
 -> MediumLevelILForceVerSsaRec -> Bool)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> Bool)
-> Eq MediumLevelILForceVerSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
== :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
$c/= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
/= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
Eq, Eq MediumLevelILForceVerSsaRec
Eq MediumLevelILForceVerSsaRec =>
(MediumLevelILForceVerSsaRec
 -> MediumLevelILForceVerSsaRec -> Ordering)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> Bool)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> Bool)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> Bool)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> Bool)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec)
-> (MediumLevelILForceVerSsaRec
    -> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec)
-> Ord MediumLevelILForceVerSsaRec
MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> Ordering
MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> Ordering
compare :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> Ordering
$c< :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
< :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
$c<= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
<= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
$c> :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
> :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
$c>= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
>= :: MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec -> Bool
$cmax :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec
max :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec
$cmin :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec
min :: MediumLevelILForceVerSsaRec
-> MediumLevelILForceVerSsaRec -> MediumLevelILForceVerSsaRec
Ord)

data MediumLevelILLoadRec = MediumLevelILLoadRec
  { MediumLevelILLoadRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILLoadRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLoadRec -> ShowS
[MediumLevelILLoadRec] -> ShowS
MediumLevelILLoadRec -> String
(Int -> MediumLevelILLoadRec -> ShowS)
-> (MediumLevelILLoadRec -> String)
-> ([MediumLevelILLoadRec] -> ShowS)
-> Show MediumLevelILLoadRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLoadRec -> ShowS
showsPrec :: Int -> MediumLevelILLoadRec -> ShowS
$cshow :: MediumLevelILLoadRec -> String
show :: MediumLevelILLoadRec -> String
$cshowList :: [MediumLevelILLoadRec] -> ShowS
showList :: [MediumLevelILLoadRec] -> ShowS
Show, MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
(MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> (MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> Eq MediumLevelILLoadRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
== :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
$c/= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
/= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
Eq, Eq MediumLevelILLoadRec
Eq MediumLevelILLoadRec =>
(MediumLevelILLoadRec -> MediumLevelILLoadRec -> Ordering)
-> (MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> (MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> (MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> (MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool)
-> (MediumLevelILLoadRec
    -> MediumLevelILLoadRec -> MediumLevelILLoadRec)
-> (MediumLevelILLoadRec
    -> MediumLevelILLoadRec -> MediumLevelILLoadRec)
-> Ord MediumLevelILLoadRec
MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
MediumLevelILLoadRec -> MediumLevelILLoadRec -> Ordering
MediumLevelILLoadRec
-> MediumLevelILLoadRec -> MediumLevelILLoadRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Ordering
compare :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Ordering
$c< :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
< :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
$c<= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
<= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
$c> :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
> :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
$c>= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
>= :: MediumLevelILLoadRec -> MediumLevelILLoadRec -> Bool
$cmax :: MediumLevelILLoadRec
-> MediumLevelILLoadRec -> MediumLevelILLoadRec
max :: MediumLevelILLoadRec
-> MediumLevelILLoadRec -> MediumLevelILLoadRec
$cmin :: MediumLevelILLoadRec
-> MediumLevelILLoadRec -> MediumLevelILLoadRec
min :: MediumLevelILLoadRec
-> MediumLevelILLoadRec -> MediumLevelILLoadRec
Ord)

data MediumLevelILLoadStructRec = MediumLevelILLoadStructRec
  { MediumLevelILLoadStructRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILLoadStructRec -> Int
offset :: Int,
    MediumLevelILLoadStructRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILLoadStructRec -> ShowS
[MediumLevelILLoadStructRec] -> ShowS
MediumLevelILLoadStructRec -> String
(Int -> MediumLevelILLoadStructRec -> ShowS)
-> (MediumLevelILLoadStructRec -> String)
-> ([MediumLevelILLoadStructRec] -> ShowS)
-> Show MediumLevelILLoadStructRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILLoadStructRec -> ShowS
showsPrec :: Int -> MediumLevelILLoadStructRec -> ShowS
$cshow :: MediumLevelILLoadStructRec -> String
show :: MediumLevelILLoadStructRec -> String
$cshowList :: [MediumLevelILLoadStructRec] -> ShowS
showList :: [MediumLevelILLoadStructRec] -> ShowS
Show, MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
(MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> Bool)
-> Eq MediumLevelILLoadStructRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
== :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
$c/= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
/= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
Eq, Eq MediumLevelILLoadStructRec
Eq MediumLevelILLoadStructRec =>
(MediumLevelILLoadStructRec
 -> MediumLevelILLoadStructRec -> Ordering)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> Bool)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> Bool)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> Bool)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> Bool)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec)
-> (MediumLevelILLoadStructRec
    -> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec)
-> Ord MediumLevelILLoadStructRec
MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> Ordering
MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> Ordering
compare :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> Ordering
$c< :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
< :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
$c<= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
<= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
$c> :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
> :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
$c>= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
>= :: MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec -> Bool
$cmax :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec
max :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec
$cmin :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec
min :: MediumLevelILLoadStructRec
-> MediumLevelILLoadStructRec -> MediumLevelILLoadStructRec
Ord)

data MediumLevelILStoreRec = MediumLevelILStoreRec
  { MediumLevelILStoreRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILStoreRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILStoreRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILStoreRec -> ShowS
[MediumLevelILStoreRec] -> ShowS
MediumLevelILStoreRec -> String
(Int -> MediumLevelILStoreRec -> ShowS)
-> (MediumLevelILStoreRec -> String)
-> ([MediumLevelILStoreRec] -> ShowS)
-> Show MediumLevelILStoreRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILStoreRec -> ShowS
showsPrec :: Int -> MediumLevelILStoreRec -> ShowS
$cshow :: MediumLevelILStoreRec -> String
show :: MediumLevelILStoreRec -> String
$cshowList :: [MediumLevelILStoreRec] -> ShowS
showList :: [MediumLevelILStoreRec] -> ShowS
Show, MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
(MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> (MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> Eq MediumLevelILStoreRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
== :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
$c/= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
/= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
Eq, Eq MediumLevelILStoreRec
Eq MediumLevelILStoreRec =>
(MediumLevelILStoreRec -> MediumLevelILStoreRec -> Ordering)
-> (MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> (MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> (MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> (MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool)
-> (MediumLevelILStoreRec
    -> MediumLevelILStoreRec -> MediumLevelILStoreRec)
-> (MediumLevelILStoreRec
    -> MediumLevelILStoreRec -> MediumLevelILStoreRec)
-> Ord MediumLevelILStoreRec
MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
MediumLevelILStoreRec -> MediumLevelILStoreRec -> Ordering
MediumLevelILStoreRec
-> MediumLevelILStoreRec -> MediumLevelILStoreRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Ordering
compare :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Ordering
$c< :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
< :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
$c<= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
<= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
$c> :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
> :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
$c>= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
>= :: MediumLevelILStoreRec -> MediumLevelILStoreRec -> Bool
$cmax :: MediumLevelILStoreRec
-> MediumLevelILStoreRec -> MediumLevelILStoreRec
max :: MediumLevelILStoreRec
-> MediumLevelILStoreRec -> MediumLevelILStoreRec
$cmin :: MediumLevelILStoreRec
-> MediumLevelILStoreRec -> MediumLevelILStoreRec
min :: MediumLevelILStoreRec
-> MediumLevelILStoreRec -> MediumLevelILStoreRec
Ord)

data MediumLevelILStoreStructRec = MediumLevelILStoreStructRec
  { MediumLevelILStoreStructRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILStoreStructRec -> Int
offset :: Int,
    MediumLevelILStoreStructRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILStoreStructRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILStoreStructRec -> ShowS
[MediumLevelILStoreStructRec] -> ShowS
MediumLevelILStoreStructRec -> String
(Int -> MediumLevelILStoreStructRec -> ShowS)
-> (MediumLevelILStoreStructRec -> String)
-> ([MediumLevelILStoreStructRec] -> ShowS)
-> Show MediumLevelILStoreStructRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILStoreStructRec -> ShowS
showsPrec :: Int -> MediumLevelILStoreStructRec -> ShowS
$cshow :: MediumLevelILStoreStructRec -> String
show :: MediumLevelILStoreStructRec -> String
$cshowList :: [MediumLevelILStoreStructRec] -> ShowS
showList :: [MediumLevelILStoreStructRec] -> ShowS
Show, MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
(MediumLevelILStoreStructRec
 -> MediumLevelILStoreStructRec -> Bool)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> Bool)
-> Eq MediumLevelILStoreStructRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
== :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
$c/= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
/= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
Eq, Eq MediumLevelILStoreStructRec
Eq MediumLevelILStoreStructRec =>
(MediumLevelILStoreStructRec
 -> MediumLevelILStoreStructRec -> Ordering)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> Bool)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> Bool)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> Bool)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> Bool)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec)
-> (MediumLevelILStoreStructRec
    -> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec)
-> Ord MediumLevelILStoreStructRec
MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> Ordering
MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> Ordering
compare :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> Ordering
$c< :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
< :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
$c<= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
<= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
$c> :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
> :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
$c>= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
>= :: MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec -> Bool
$cmax :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec
max :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec
$cmin :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec
min :: MediumLevelILStoreStructRec
-> MediumLevelILStoreStructRec -> MediumLevelILStoreStructRec
Ord)

data MediumLevelILVarRec = MediumLevelILVarRec
  { MediumLevelILVarRec -> BNVariable
src :: BNVariable,
    MediumLevelILVarRec -> BNVariable
var :: BNVariable,
    MediumLevelILVarRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarRec -> ShowS
[MediumLevelILVarRec] -> ShowS
MediumLevelILVarRec -> String
(Int -> MediumLevelILVarRec -> ShowS)
-> (MediumLevelILVarRec -> String)
-> ([MediumLevelILVarRec] -> ShowS)
-> Show MediumLevelILVarRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarRec -> ShowS
showsPrec :: Int -> MediumLevelILVarRec -> ShowS
$cshow :: MediumLevelILVarRec -> String
show :: MediumLevelILVarRec -> String
$cshowList :: [MediumLevelILVarRec] -> ShowS
showList :: [MediumLevelILVarRec] -> ShowS
Show, MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
(MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> (MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> Eq MediumLevelILVarRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
== :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
$c/= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
/= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
Eq, Eq MediumLevelILVarRec
Eq MediumLevelILVarRec =>
(MediumLevelILVarRec -> MediumLevelILVarRec -> Ordering)
-> (MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> (MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> (MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> (MediumLevelILVarRec -> MediumLevelILVarRec -> Bool)
-> (MediumLevelILVarRec
    -> MediumLevelILVarRec -> MediumLevelILVarRec)
-> (MediumLevelILVarRec
    -> MediumLevelILVarRec -> MediumLevelILVarRec)
-> Ord MediumLevelILVarRec
MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
MediumLevelILVarRec -> MediumLevelILVarRec -> Ordering
MediumLevelILVarRec -> MediumLevelILVarRec -> MediumLevelILVarRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarRec -> MediumLevelILVarRec -> Ordering
compare :: MediumLevelILVarRec -> MediumLevelILVarRec -> Ordering
$c< :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
< :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
$c<= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
<= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
$c> :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
> :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
$c>= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
>= :: MediumLevelILVarRec -> MediumLevelILVarRec -> Bool
$cmax :: MediumLevelILVarRec -> MediumLevelILVarRec -> MediumLevelILVarRec
max :: MediumLevelILVarRec -> MediumLevelILVarRec -> MediumLevelILVarRec
$cmin :: MediumLevelILVarRec -> MediumLevelILVarRec -> MediumLevelILVarRec
min :: MediumLevelILVarRec -> MediumLevelILVarRec -> MediumLevelILVarRec
Ord)

data MediumLevelILVarFieldRec = MediumLevelILVarFieldRec
  { MediumLevelILVarFieldRec -> BNVariable
src :: BNVariable,
    MediumLevelILVarFieldRec -> Int
offset :: Int,
    MediumLevelILVarFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarFieldRec -> ShowS
[MediumLevelILVarFieldRec] -> ShowS
MediumLevelILVarFieldRec -> String
(Int -> MediumLevelILVarFieldRec -> ShowS)
-> (MediumLevelILVarFieldRec -> String)
-> ([MediumLevelILVarFieldRec] -> ShowS)
-> Show MediumLevelILVarFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarFieldRec -> ShowS
$cshow :: MediumLevelILVarFieldRec -> String
show :: MediumLevelILVarFieldRec -> String
$cshowList :: [MediumLevelILVarFieldRec] -> ShowS
showList :: [MediumLevelILVarFieldRec] -> ShowS
Show, MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
(MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> (MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> Eq MediumLevelILVarFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
== :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
$c/= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
/= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
Eq, Eq MediumLevelILVarFieldRec
Eq MediumLevelILVarFieldRec =>
(MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Ordering)
-> (MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> (MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> (MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> (MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool)
-> (MediumLevelILVarFieldRec
    -> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec)
-> (MediumLevelILVarFieldRec
    -> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec)
-> Ord MediumLevelILVarFieldRec
MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Ordering
MediumLevelILVarFieldRec
-> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Ordering
compare :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Ordering
$c< :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
< :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
$c<= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
<= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
$c> :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
> :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
$c>= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
>= :: MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec -> Bool
$cmax :: MediumLevelILVarFieldRec
-> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec
max :: MediumLevelILVarFieldRec
-> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec
$cmin :: MediumLevelILVarFieldRec
-> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec
min :: MediumLevelILVarFieldRec
-> MediumLevelILVarFieldRec -> MediumLevelILVarFieldRec
Ord)

data MediumLevelILVarSplitRec = MediumLevelILVarSplitRec
  { MediumLevelILVarSplitRec -> BNVariable
high :: BNVariable,
    MediumLevelILVarSplitRec -> BNVariable
low :: BNVariable,
    MediumLevelILVarSplitRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarSplitRec -> ShowS
[MediumLevelILVarSplitRec] -> ShowS
MediumLevelILVarSplitRec -> String
(Int -> MediumLevelILVarSplitRec -> ShowS)
-> (MediumLevelILVarSplitRec -> String)
-> ([MediumLevelILVarSplitRec] -> ShowS)
-> Show MediumLevelILVarSplitRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarSplitRec -> ShowS
showsPrec :: Int -> MediumLevelILVarSplitRec -> ShowS
$cshow :: MediumLevelILVarSplitRec -> String
show :: MediumLevelILVarSplitRec -> String
$cshowList :: [MediumLevelILVarSplitRec] -> ShowS
showList :: [MediumLevelILVarSplitRec] -> ShowS
Show, MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
(MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> (MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> Eq MediumLevelILVarSplitRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
== :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
$c/= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
/= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
Eq, Eq MediumLevelILVarSplitRec
Eq MediumLevelILVarSplitRec =>
(MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Ordering)
-> (MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> (MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> (MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> (MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool)
-> (MediumLevelILVarSplitRec
    -> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec)
-> (MediumLevelILVarSplitRec
    -> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec)
-> Ord MediumLevelILVarSplitRec
MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Ordering
MediumLevelILVarSplitRec
-> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Ordering
compare :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Ordering
$c< :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
< :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
$c<= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
<= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
$c> :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
> :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
$c>= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
>= :: MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec -> Bool
$cmax :: MediumLevelILVarSplitRec
-> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec
max :: MediumLevelILVarSplitRec
-> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec
$cmin :: MediumLevelILVarSplitRec
-> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec
min :: MediumLevelILVarSplitRec
-> MediumLevelILVarSplitRec -> MediumLevelILVarSplitRec
Ord)

data MediumLevelILExternPtrRec = MediumLevelILExternPtrRec
  { MediumLevelILExternPtrRec -> Int
constant :: Int,
    MediumLevelILExternPtrRec -> Int
offset :: Int,
    MediumLevelILExternPtrRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILExternPtrRec -> ShowS
[MediumLevelILExternPtrRec] -> ShowS
MediumLevelILExternPtrRec -> String
(Int -> MediumLevelILExternPtrRec -> ShowS)
-> (MediumLevelILExternPtrRec -> String)
-> ([MediumLevelILExternPtrRec] -> ShowS)
-> Show MediumLevelILExternPtrRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILExternPtrRec -> ShowS
showsPrec :: Int -> MediumLevelILExternPtrRec -> ShowS
$cshow :: MediumLevelILExternPtrRec -> String
show :: MediumLevelILExternPtrRec -> String
$cshowList :: [MediumLevelILExternPtrRec] -> ShowS
showList :: [MediumLevelILExternPtrRec] -> ShowS
Show, MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
(MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> (MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> Eq MediumLevelILExternPtrRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
== :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
$c/= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
/= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
Eq, Eq MediumLevelILExternPtrRec
Eq MediumLevelILExternPtrRec =>
(MediumLevelILExternPtrRec
 -> MediumLevelILExternPtrRec -> Ordering)
-> (MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> (MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> (MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> (MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool)
-> (MediumLevelILExternPtrRec
    -> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec)
-> (MediumLevelILExternPtrRec
    -> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec)
-> Ord MediumLevelILExternPtrRec
MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Ordering
MediumLevelILExternPtrRec
-> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Ordering
compare :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Ordering
$c< :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
< :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
$c<= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
<= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
$c> :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
> :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
$c>= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
>= :: MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec -> Bool
$cmax :: MediumLevelILExternPtrRec
-> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec
max :: MediumLevelILExternPtrRec
-> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec
$cmin :: MediumLevelILExternPtrRec
-> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec
min :: MediumLevelILExternPtrRec
-> MediumLevelILExternPtrRec -> MediumLevelILExternPtrRec
Ord)

data MediumLevelILRetHintRec = MediumLevelILRetHintRec
  { MediumLevelILRetHintRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILRetHintRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRetHintRec -> ShowS
[MediumLevelILRetHintRec] -> ShowS
MediumLevelILRetHintRec -> String
(Int -> MediumLevelILRetHintRec -> ShowS)
-> (MediumLevelILRetHintRec -> String)
-> ([MediumLevelILRetHintRec] -> ShowS)
-> Show MediumLevelILRetHintRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRetHintRec -> ShowS
showsPrec :: Int -> MediumLevelILRetHintRec -> ShowS
$cshow :: MediumLevelILRetHintRec -> String
show :: MediumLevelILRetHintRec -> String
$cshowList :: [MediumLevelILRetHintRec] -> ShowS
showList :: [MediumLevelILRetHintRec] -> ShowS
Show, MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
(MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> (MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> Eq MediumLevelILRetHintRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
== :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
$c/= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
/= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
Eq, Eq MediumLevelILRetHintRec
Eq MediumLevelILRetHintRec =>
(MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Ordering)
-> (MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> (MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> (MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> (MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool)
-> (MediumLevelILRetHintRec
    -> MediumLevelILRetHintRec -> MediumLevelILRetHintRec)
-> (MediumLevelILRetHintRec
    -> MediumLevelILRetHintRec -> MediumLevelILRetHintRec)
-> Ord MediumLevelILRetHintRec
MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Ordering
MediumLevelILRetHintRec
-> MediumLevelILRetHintRec -> MediumLevelILRetHintRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Ordering
compare :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Ordering
$c< :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
< :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
$c<= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
<= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
$c> :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
> :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
$c>= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
>= :: MediumLevelILRetHintRec -> MediumLevelILRetHintRec -> Bool
$cmax :: MediumLevelILRetHintRec
-> MediumLevelILRetHintRec -> MediumLevelILRetHintRec
max :: MediumLevelILRetHintRec
-> MediumLevelILRetHintRec -> MediumLevelILRetHintRec
$cmin :: MediumLevelILRetHintRec
-> MediumLevelILRetHintRec -> MediumLevelILRetHintRec
min :: MediumLevelILRetHintRec
-> MediumLevelILRetHintRec -> MediumLevelILRetHintRec
Ord)

data MediumLevelILCallRec = MediumLevelILCallRec
  { MediumLevelILCallRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILCallRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILCallRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILCallRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallRec -> ShowS
[MediumLevelILCallRec] -> ShowS
MediumLevelILCallRec -> String
(Int -> MediumLevelILCallRec -> ShowS)
-> (MediumLevelILCallRec -> String)
-> ([MediumLevelILCallRec] -> ShowS)
-> Show MediumLevelILCallRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallRec -> ShowS
showsPrec :: Int -> MediumLevelILCallRec -> ShowS
$cshow :: MediumLevelILCallRec -> String
show :: MediumLevelILCallRec -> String
$cshowList :: [MediumLevelILCallRec] -> ShowS
showList :: [MediumLevelILCallRec] -> ShowS
Show, MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
(MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> (MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> Eq MediumLevelILCallRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
== :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
$c/= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
/= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
Eq, Eq MediumLevelILCallRec
Eq MediumLevelILCallRec =>
(MediumLevelILCallRec -> MediumLevelILCallRec -> Ordering)
-> (MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> (MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> (MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> (MediumLevelILCallRec -> MediumLevelILCallRec -> Bool)
-> (MediumLevelILCallRec
    -> MediumLevelILCallRec -> MediumLevelILCallRec)
-> (MediumLevelILCallRec
    -> MediumLevelILCallRec -> MediumLevelILCallRec)
-> Ord MediumLevelILCallRec
MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
MediumLevelILCallRec -> MediumLevelILCallRec -> Ordering
MediumLevelILCallRec
-> MediumLevelILCallRec -> MediumLevelILCallRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallRec -> MediumLevelILCallRec -> Ordering
compare :: MediumLevelILCallRec -> MediumLevelILCallRec -> Ordering
$c< :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
< :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
$c<= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
<= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
$c> :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
> :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
$c>= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
>= :: MediumLevelILCallRec -> MediumLevelILCallRec -> Bool
$cmax :: MediumLevelILCallRec
-> MediumLevelILCallRec -> MediumLevelILCallRec
max :: MediumLevelILCallRec
-> MediumLevelILCallRec -> MediumLevelILCallRec
$cmin :: MediumLevelILCallRec
-> MediumLevelILCallRec -> MediumLevelILCallRec
min :: MediumLevelILCallRec
-> MediumLevelILCallRec -> MediumLevelILCallRec
Ord)

data MediumLevelILBpRec = MediumLevelILBpRec
  {MediumLevelILBpRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction}
  deriving (Int -> MediumLevelILBpRec -> ShowS
[MediumLevelILBpRec] -> ShowS
MediumLevelILBpRec -> String
(Int -> MediumLevelILBpRec -> ShowS)
-> (MediumLevelILBpRec -> String)
-> ([MediumLevelILBpRec] -> ShowS)
-> Show MediumLevelILBpRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILBpRec -> ShowS
showsPrec :: Int -> MediumLevelILBpRec -> ShowS
$cshow :: MediumLevelILBpRec -> String
show :: MediumLevelILBpRec -> String
$cshowList :: [MediumLevelILBpRec] -> ShowS
showList :: [MediumLevelILBpRec] -> ShowS
Show, MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
(MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> Eq MediumLevelILBpRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
== :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
$c/= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
/= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
Eq, Eq MediumLevelILBpRec
Eq MediumLevelILBpRec =>
(MediumLevelILBpRec -> MediumLevelILBpRec -> Ordering)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> Bool)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec)
-> (MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec)
-> Ord MediumLevelILBpRec
MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
MediumLevelILBpRec -> MediumLevelILBpRec -> Ordering
MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILBpRec -> MediumLevelILBpRec -> Ordering
compare :: MediumLevelILBpRec -> MediumLevelILBpRec -> Ordering
$c< :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
< :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
$c<= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
<= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
$c> :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
> :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
$c>= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
>= :: MediumLevelILBpRec -> MediumLevelILBpRec -> Bool
$cmax :: MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec
max :: MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec
$cmin :: MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec
min :: MediumLevelILBpRec -> MediumLevelILBpRec -> MediumLevelILBpRec
Ord)

data MediumLevelILTrapRec = MediumLevelILTrapRec
  { MediumLevelILTrapRec -> Int
vector :: Int,
    MediumLevelILTrapRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTrapRec -> ShowS
[MediumLevelILTrapRec] -> ShowS
MediumLevelILTrapRec -> String
(Int -> MediumLevelILTrapRec -> ShowS)
-> (MediumLevelILTrapRec -> String)
-> ([MediumLevelILTrapRec] -> ShowS)
-> Show MediumLevelILTrapRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTrapRec -> ShowS
showsPrec :: Int -> MediumLevelILTrapRec -> ShowS
$cshow :: MediumLevelILTrapRec -> String
show :: MediumLevelILTrapRec -> String
$cshowList :: [MediumLevelILTrapRec] -> ShowS
showList :: [MediumLevelILTrapRec] -> ShowS
Show, MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
(MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> (MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> Eq MediumLevelILTrapRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
== :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
$c/= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
/= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
Eq, Eq MediumLevelILTrapRec
Eq MediumLevelILTrapRec =>
(MediumLevelILTrapRec -> MediumLevelILTrapRec -> Ordering)
-> (MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> (MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> (MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> (MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool)
-> (MediumLevelILTrapRec
    -> MediumLevelILTrapRec -> MediumLevelILTrapRec)
-> (MediumLevelILTrapRec
    -> MediumLevelILTrapRec -> MediumLevelILTrapRec)
-> Ord MediumLevelILTrapRec
MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
MediumLevelILTrapRec -> MediumLevelILTrapRec -> Ordering
MediumLevelILTrapRec
-> MediumLevelILTrapRec -> MediumLevelILTrapRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Ordering
compare :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Ordering
$c< :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
< :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
$c<= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
<= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
$c> :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
> :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
$c>= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
>= :: MediumLevelILTrapRec -> MediumLevelILTrapRec -> Bool
$cmax :: MediumLevelILTrapRec
-> MediumLevelILTrapRec -> MediumLevelILTrapRec
max :: MediumLevelILTrapRec
-> MediumLevelILTrapRec -> MediumLevelILTrapRec
$cmin :: MediumLevelILTrapRec
-> MediumLevelILTrapRec -> MediumLevelILTrapRec
min :: MediumLevelILTrapRec
-> MediumLevelILTrapRec -> MediumLevelILTrapRec
Ord)

data MediumLevelILUndefRec = MediumLevelILUndefRec
  {MediumLevelILUndefRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction}
  deriving (Int -> MediumLevelILUndefRec -> ShowS
[MediumLevelILUndefRec] -> ShowS
MediumLevelILUndefRec -> String
(Int -> MediumLevelILUndefRec -> ShowS)
-> (MediumLevelILUndefRec -> String)
-> ([MediumLevelILUndefRec] -> ShowS)
-> Show MediumLevelILUndefRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILUndefRec -> ShowS
showsPrec :: Int -> MediumLevelILUndefRec -> ShowS
$cshow :: MediumLevelILUndefRec -> String
show :: MediumLevelILUndefRec -> String
$cshowList :: [MediumLevelILUndefRec] -> ShowS
showList :: [MediumLevelILUndefRec] -> ShowS
Show, MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
(MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> (MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> Eq MediumLevelILUndefRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
== :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
$c/= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
/= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
Eq, Eq MediumLevelILUndefRec
Eq MediumLevelILUndefRec =>
(MediumLevelILUndefRec -> MediumLevelILUndefRec -> Ordering)
-> (MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> (MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> (MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> (MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool)
-> (MediumLevelILUndefRec
    -> MediumLevelILUndefRec -> MediumLevelILUndefRec)
-> (MediumLevelILUndefRec
    -> MediumLevelILUndefRec -> MediumLevelILUndefRec)
-> Ord MediumLevelILUndefRec
MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
MediumLevelILUndefRec -> MediumLevelILUndefRec -> Ordering
MediumLevelILUndefRec
-> MediumLevelILUndefRec -> MediumLevelILUndefRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Ordering
compare :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Ordering
$c< :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
< :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
$c<= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
<= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
$c> :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
> :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
$c>= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
>= :: MediumLevelILUndefRec -> MediumLevelILUndefRec -> Bool
$cmax :: MediumLevelILUndefRec
-> MediumLevelILUndefRec -> MediumLevelILUndefRec
max :: MediumLevelILUndefRec
-> MediumLevelILUndefRec -> MediumLevelILUndefRec
$cmin :: MediumLevelILUndefRec
-> MediumLevelILUndefRec -> MediumLevelILUndefRec
min :: MediumLevelILUndefRec
-> MediumLevelILUndefRec -> MediumLevelILUndefRec
Ord)

data MediumLevelILUnimplRec = MediumLevelILUnimplRec
  {MediumLevelILUnimplRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction}
  deriving (Int -> MediumLevelILUnimplRec -> ShowS
[MediumLevelILUnimplRec] -> ShowS
MediumLevelILUnimplRec -> String
(Int -> MediumLevelILUnimplRec -> ShowS)
-> (MediumLevelILUnimplRec -> String)
-> ([MediumLevelILUnimplRec] -> ShowS)
-> Show MediumLevelILUnimplRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILUnimplRec -> ShowS
showsPrec :: Int -> MediumLevelILUnimplRec -> ShowS
$cshow :: MediumLevelILUnimplRec -> String
show :: MediumLevelILUnimplRec -> String
$cshowList :: [MediumLevelILUnimplRec] -> ShowS
showList :: [MediumLevelILUnimplRec] -> ShowS
Show, MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
(MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> (MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> Eq MediumLevelILUnimplRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
== :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
$c/= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
/= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
Eq, Eq MediumLevelILUnimplRec
Eq MediumLevelILUnimplRec =>
(MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Ordering)
-> (MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> (MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> (MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> (MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool)
-> (MediumLevelILUnimplRec
    -> MediumLevelILUnimplRec -> MediumLevelILUnimplRec)
-> (MediumLevelILUnimplRec
    -> MediumLevelILUnimplRec -> MediumLevelILUnimplRec)
-> Ord MediumLevelILUnimplRec
MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Ordering
MediumLevelILUnimplRec
-> MediumLevelILUnimplRec -> MediumLevelILUnimplRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Ordering
compare :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Ordering
$c< :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
< :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
$c<= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
<= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
$c> :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
> :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
$c>= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
>= :: MediumLevelILUnimplRec -> MediumLevelILUnimplRec -> Bool
$cmax :: MediumLevelILUnimplRec
-> MediumLevelILUnimplRec -> MediumLevelILUnimplRec
max :: MediumLevelILUnimplRec
-> MediumLevelILUnimplRec -> MediumLevelILUnimplRec
$cmin :: MediumLevelILUnimplRec
-> MediumLevelILUnimplRec -> MediumLevelILUnimplRec
min :: MediumLevelILUnimplRec
-> MediumLevelILUnimplRec -> MediumLevelILUnimplRec
Ord)

data MediumLevelILUnimplMemRec = MediumLevelILUnimplMemRec
  { MediumLevelILUnimplMemRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILUnimplMemRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILUnimplMemRec -> ShowS
[MediumLevelILUnimplMemRec] -> ShowS
MediumLevelILUnimplMemRec -> String
(Int -> MediumLevelILUnimplMemRec -> ShowS)
-> (MediumLevelILUnimplMemRec -> String)
-> ([MediumLevelILUnimplMemRec] -> ShowS)
-> Show MediumLevelILUnimplMemRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILUnimplMemRec -> ShowS
showsPrec :: Int -> MediumLevelILUnimplMemRec -> ShowS
$cshow :: MediumLevelILUnimplMemRec -> String
show :: MediumLevelILUnimplMemRec -> String
$cshowList :: [MediumLevelILUnimplMemRec] -> ShowS
showList :: [MediumLevelILUnimplMemRec] -> ShowS
Show, MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
(MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> (MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> Eq MediumLevelILUnimplMemRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
== :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
$c/= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
/= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
Eq, Eq MediumLevelILUnimplMemRec
Eq MediumLevelILUnimplMemRec =>
(MediumLevelILUnimplMemRec
 -> MediumLevelILUnimplMemRec -> Ordering)
-> (MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> (MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> (MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> (MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool)
-> (MediumLevelILUnimplMemRec
    -> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec)
-> (MediumLevelILUnimplMemRec
    -> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec)
-> Ord MediumLevelILUnimplMemRec
MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Ordering
MediumLevelILUnimplMemRec
-> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Ordering
compare :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Ordering
$c< :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
< :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
$c<= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
<= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
$c> :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
> :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
$c>= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
>= :: MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec -> Bool
$cmax :: MediumLevelILUnimplMemRec
-> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec
max :: MediumLevelILUnimplMemRec
-> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec
$cmin :: MediumLevelILUnimplMemRec
-> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec
min :: MediumLevelILUnimplMemRec
-> MediumLevelILUnimplMemRec -> MediumLevelILUnimplMemRec
Ord)

data MediumLevelILSetVarSplitSsaRec = MediumLevelILSetVarSplitSsaRec
  { MediumLevelILSetVarSplitSsaRec -> BNSSAVariable
high :: BNSSAVariable,
    MediumLevelILSetVarSplitSsaRec -> BNSSAVariable
low :: BNSSAVariable,
    MediumLevelILSetVarSplitSsaRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILSetVarSplitSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSetVarSplitSsaRec -> ShowS
[MediumLevelILSetVarSplitSsaRec] -> ShowS
MediumLevelILSetVarSplitSsaRec -> String
(Int -> MediumLevelILSetVarSplitSsaRec -> ShowS)
-> (MediumLevelILSetVarSplitSsaRec -> String)
-> ([MediumLevelILSetVarSplitSsaRec] -> ShowS)
-> Show MediumLevelILSetVarSplitSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSetVarSplitSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILSetVarSplitSsaRec -> ShowS
$cshow :: MediumLevelILSetVarSplitSsaRec -> String
show :: MediumLevelILSetVarSplitSsaRec -> String
$cshowList :: [MediumLevelILSetVarSplitSsaRec] -> ShowS
showList :: [MediumLevelILSetVarSplitSsaRec] -> ShowS
Show, MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
(MediumLevelILSetVarSplitSsaRec
 -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> Eq MediumLevelILSetVarSplitSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
== :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
$c/= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
/= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
Eq, Eq MediumLevelILSetVarSplitSsaRec
Eq MediumLevelILSetVarSplitSsaRec =>
(MediumLevelILSetVarSplitSsaRec
 -> MediumLevelILSetVarSplitSsaRec -> Ordering)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec -> Bool)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec)
-> (MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec
    -> MediumLevelILSetVarSplitSsaRec)
-> Ord MediumLevelILSetVarSplitSsaRec
MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Ordering
MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> MediumLevelILSetVarSplitSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Ordering
compare :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Ordering
$c< :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
< :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
$c<= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
<= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
$c> :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
> :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
$c>= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
>= :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> Bool
$cmax :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> MediumLevelILSetVarSplitSsaRec
max :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> MediumLevelILSetVarSplitSsaRec
$cmin :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> MediumLevelILSetVarSplitSsaRec
min :: MediumLevelILSetVarSplitSsaRec
-> MediumLevelILSetVarSplitSsaRec -> MediumLevelILSetVarSplitSsaRec
Ord)

data MediumLevelILVarSplitSsaRec = MediumLevelILVarSplitSsaRec
  { MediumLevelILVarSplitSsaRec -> BNSSAVariable
high :: BNSSAVariable,
    MediumLevelILVarSplitSsaRec -> BNSSAVariable
low :: BNSSAVariable,
    MediumLevelILVarSplitSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarSplitSsaRec -> ShowS
[MediumLevelILVarSplitSsaRec] -> ShowS
MediumLevelILVarSplitSsaRec -> String
(Int -> MediumLevelILVarSplitSsaRec -> ShowS)
-> (MediumLevelILVarSplitSsaRec -> String)
-> ([MediumLevelILVarSplitSsaRec] -> ShowS)
-> Show MediumLevelILVarSplitSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarSplitSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILVarSplitSsaRec -> ShowS
$cshow :: MediumLevelILVarSplitSsaRec -> String
show :: MediumLevelILVarSplitSsaRec -> String
$cshowList :: [MediumLevelILVarSplitSsaRec] -> ShowS
showList :: [MediumLevelILVarSplitSsaRec] -> ShowS
Show, MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
(MediumLevelILVarSplitSsaRec
 -> MediumLevelILVarSplitSsaRec -> Bool)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> Bool)
-> Eq MediumLevelILVarSplitSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
== :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
$c/= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
/= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
Eq, Eq MediumLevelILVarSplitSsaRec
Eq MediumLevelILVarSplitSsaRec =>
(MediumLevelILVarSplitSsaRec
 -> MediumLevelILVarSplitSsaRec -> Ordering)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> Bool)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> Bool)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> Bool)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> Bool)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec)
-> (MediumLevelILVarSplitSsaRec
    -> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec)
-> Ord MediumLevelILVarSplitSsaRec
MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> Ordering
MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> Ordering
compare :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> Ordering
$c< :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
< :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
$c<= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
<= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
$c> :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
> :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
$c>= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
>= :: MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec -> Bool
$cmax :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec
max :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec
$cmin :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec
min :: MediumLevelILVarSplitSsaRec
-> MediumLevelILVarSplitSsaRec -> MediumLevelILVarSplitSsaRec
Ord)

data MediumLevelILCallUntypedSsaRec = MediumLevelILCallUntypedSsaRec
  { MediumLevelILCallUntypedSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILCallUntypedSsaRec -> Int
outputDestMemory :: Int,
    MediumLevelILCallUntypedSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILCallUntypedSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILCallUntypedSsaRec -> Int
paramsSrcMemory :: Int,
    MediumLevelILCallUntypedSsaRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILCallUntypedSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallUntypedSsaRec -> ShowS
[MediumLevelILCallUntypedSsaRec] -> ShowS
MediumLevelILCallUntypedSsaRec -> String
(Int -> MediumLevelILCallUntypedSsaRec -> ShowS)
-> (MediumLevelILCallUntypedSsaRec -> String)
-> ([MediumLevelILCallUntypedSsaRec] -> ShowS)
-> Show MediumLevelILCallUntypedSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallUntypedSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILCallUntypedSsaRec -> ShowS
$cshow :: MediumLevelILCallUntypedSsaRec -> String
show :: MediumLevelILCallUntypedSsaRec -> String
$cshowList :: [MediumLevelILCallUntypedSsaRec] -> ShowS
showList :: [MediumLevelILCallUntypedSsaRec] -> ShowS
Show, MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
(MediumLevelILCallUntypedSsaRec
 -> MediumLevelILCallUntypedSsaRec -> Bool)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec -> Bool)
-> Eq MediumLevelILCallUntypedSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
== :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
$c/= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
/= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
Eq, Eq MediumLevelILCallUntypedSsaRec
Eq MediumLevelILCallUntypedSsaRec =>
(MediumLevelILCallUntypedSsaRec
 -> MediumLevelILCallUntypedSsaRec -> Ordering)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec -> Bool)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec -> Bool)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec -> Bool)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec -> Bool)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec)
-> (MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec
    -> MediumLevelILCallUntypedSsaRec)
-> Ord MediumLevelILCallUntypedSsaRec
MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Ordering
MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> MediumLevelILCallUntypedSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Ordering
compare :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Ordering
$c< :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
< :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
$c<= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
<= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
$c> :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
> :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
$c>= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
>= :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> Bool
$cmax :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> MediumLevelILCallUntypedSsaRec
max :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> MediumLevelILCallUntypedSsaRec
$cmin :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> MediumLevelILCallUntypedSsaRec
min :: MediumLevelILCallUntypedSsaRec
-> MediumLevelILCallUntypedSsaRec -> MediumLevelILCallUntypedSsaRec
Ord)

data MediumLevelILCallUntypedRec = MediumLevelILCallUntypedRec
  { MediumLevelILCallUntypedRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILCallUntypedRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILCallUntypedRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILCallUntypedRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILCallUntypedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCallUntypedRec -> ShowS
[MediumLevelILCallUntypedRec] -> ShowS
MediumLevelILCallUntypedRec -> String
(Int -> MediumLevelILCallUntypedRec -> ShowS)
-> (MediumLevelILCallUntypedRec -> String)
-> ([MediumLevelILCallUntypedRec] -> ShowS)
-> Show MediumLevelILCallUntypedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCallUntypedRec -> ShowS
showsPrec :: Int -> MediumLevelILCallUntypedRec -> ShowS
$cshow :: MediumLevelILCallUntypedRec -> String
show :: MediumLevelILCallUntypedRec -> String
$cshowList :: [MediumLevelILCallUntypedRec] -> ShowS
showList :: [MediumLevelILCallUntypedRec] -> ShowS
Show, MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
(MediumLevelILCallUntypedRec
 -> MediumLevelILCallUntypedRec -> Bool)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> Bool)
-> Eq MediumLevelILCallUntypedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
== :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
$c/= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
/= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
Eq, Eq MediumLevelILCallUntypedRec
Eq MediumLevelILCallUntypedRec =>
(MediumLevelILCallUntypedRec
 -> MediumLevelILCallUntypedRec -> Ordering)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> Bool)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> Bool)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> Bool)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> Bool)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec)
-> (MediumLevelILCallUntypedRec
    -> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec)
-> Ord MediumLevelILCallUntypedRec
MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> Ordering
MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> Ordering
compare :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> Ordering
$c< :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
< :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
$c<= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
<= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
$c> :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
> :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
$c>= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
>= :: MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec -> Bool
$cmax :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec
max :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec
$cmin :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec
min :: MediumLevelILCallUntypedRec
-> MediumLevelILCallUntypedRec -> MediumLevelILCallUntypedRec
Ord)

data MediumLevelILSeparateParamListRec = MediumLevelILSeparateParamListRec
  { MediumLevelILSeparateParamListRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSeparateParamListRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSeparateParamListRec -> ShowS
[MediumLevelILSeparateParamListRec] -> ShowS
MediumLevelILSeparateParamListRec -> String
(Int -> MediumLevelILSeparateParamListRec -> ShowS)
-> (MediumLevelILSeparateParamListRec -> String)
-> ([MediumLevelILSeparateParamListRec] -> ShowS)
-> Show MediumLevelILSeparateParamListRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSeparateParamListRec -> ShowS
showsPrec :: Int -> MediumLevelILSeparateParamListRec -> ShowS
$cshow :: MediumLevelILSeparateParamListRec -> String
show :: MediumLevelILSeparateParamListRec -> String
$cshowList :: [MediumLevelILSeparateParamListRec] -> ShowS
showList :: [MediumLevelILSeparateParamListRec] -> ShowS
Show, MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
(MediumLevelILSeparateParamListRec
 -> MediumLevelILSeparateParamListRec -> Bool)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec -> Bool)
-> Eq MediumLevelILSeparateParamListRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
== :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
$c/= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
/= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
Eq, Eq MediumLevelILSeparateParamListRec
Eq MediumLevelILSeparateParamListRec =>
(MediumLevelILSeparateParamListRec
 -> MediumLevelILSeparateParamListRec -> Ordering)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec -> Bool)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec -> Bool)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec -> Bool)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec -> Bool)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec)
-> (MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec
    -> MediumLevelILSeparateParamListRec)
-> Ord MediumLevelILSeparateParamListRec
MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Ordering
MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Ordering
compare :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Ordering
$c< :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
< :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
$c<= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
<= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
$c> :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
> :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
$c>= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
>= :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec -> Bool
$cmax :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
max :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
$cmin :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
min :: MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
-> MediumLevelILSeparateParamListRec
Ord)

data MediumLevelILSharedParamSlotRec = MediumLevelILSharedParamSlotRec
  { MediumLevelILSharedParamSlotRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSharedParamSlotRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSharedParamSlotRec -> ShowS
[MediumLevelILSharedParamSlotRec] -> ShowS
MediumLevelILSharedParamSlotRec -> String
(Int -> MediumLevelILSharedParamSlotRec -> ShowS)
-> (MediumLevelILSharedParamSlotRec -> String)
-> ([MediumLevelILSharedParamSlotRec] -> ShowS)
-> Show MediumLevelILSharedParamSlotRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSharedParamSlotRec -> ShowS
showsPrec :: Int -> MediumLevelILSharedParamSlotRec -> ShowS
$cshow :: MediumLevelILSharedParamSlotRec -> String
show :: MediumLevelILSharedParamSlotRec -> String
$cshowList :: [MediumLevelILSharedParamSlotRec] -> ShowS
showList :: [MediumLevelILSharedParamSlotRec] -> ShowS
Show, MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
(MediumLevelILSharedParamSlotRec
 -> MediumLevelILSharedParamSlotRec -> Bool)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec -> Bool)
-> Eq MediumLevelILSharedParamSlotRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
== :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
$c/= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
/= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
Eq, Eq MediumLevelILSharedParamSlotRec
Eq MediumLevelILSharedParamSlotRec =>
(MediumLevelILSharedParamSlotRec
 -> MediumLevelILSharedParamSlotRec -> Ordering)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec -> Bool)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec -> Bool)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec -> Bool)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec -> Bool)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec)
-> (MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec
    -> MediumLevelILSharedParamSlotRec)
-> Ord MediumLevelILSharedParamSlotRec
MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Ordering
MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Ordering
compare :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Ordering
$c< :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
< :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
$c<= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
<= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
$c> :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
> :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
$c>= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
>= :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec -> Bool
$cmax :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
max :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
$cmin :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
min :: MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
-> MediumLevelILSharedParamSlotRec
Ord)

data MediumLevelILVarOutputRec = MediumLevelILVarOutputRec
  { MediumLevelILVarOutputRec -> BNVariable
dest :: BNVariable,
    MediumLevelILVarOutputRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputRec -> ShowS
[MediumLevelILVarOutputRec] -> ShowS
MediumLevelILVarOutputRec -> String
(Int -> MediumLevelILVarOutputRec -> ShowS)
-> (MediumLevelILVarOutputRec -> String)
-> ([MediumLevelILVarOutputRec] -> ShowS)
-> Show MediumLevelILVarOutputRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputRec -> ShowS
$cshow :: MediumLevelILVarOutputRec -> String
show :: MediumLevelILVarOutputRec -> String
$cshowList :: [MediumLevelILVarOutputRec] -> ShowS
showList :: [MediumLevelILVarOutputRec] -> ShowS
Show, MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
(MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> (MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> Eq MediumLevelILVarOutputRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
== :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
$c/= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
/= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
Eq, Eq MediumLevelILVarOutputRec
Eq MediumLevelILVarOutputRec =>
(MediumLevelILVarOutputRec
 -> MediumLevelILVarOutputRec -> Ordering)
-> (MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> (MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> (MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> (MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool)
-> (MediumLevelILVarOutputRec
    -> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec)
-> (MediumLevelILVarOutputRec
    -> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec)
-> Ord MediumLevelILVarOutputRec
MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Ordering
MediumLevelILVarOutputRec
-> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Ordering
compare :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Ordering
$c< :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
< :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
$c<= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
<= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
$c> :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
> :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
$c>= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
>= :: MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec -> Bool
$cmax :: MediumLevelILVarOutputRec
-> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec
max :: MediumLevelILVarOutputRec
-> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec
$cmin :: MediumLevelILVarOutputRec
-> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec
min :: MediumLevelILVarOutputRec
-> MediumLevelILVarOutputRec -> MediumLevelILVarOutputRec
Ord)

data MediumLevelILVarOutputFieldRec = MediumLevelILVarOutputFieldRec
  { MediumLevelILVarOutputFieldRec -> BNVariable
dest :: BNVariable,
    MediumLevelILVarOutputFieldRec -> Int
offset :: Int,
    MediumLevelILVarOutputFieldRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarOutputFieldRec -> ShowS
[MediumLevelILVarOutputFieldRec] -> ShowS
MediumLevelILVarOutputFieldRec -> String
(Int -> MediumLevelILVarOutputFieldRec -> ShowS)
-> (MediumLevelILVarOutputFieldRec -> String)
-> ([MediumLevelILVarOutputFieldRec] -> ShowS)
-> Show MediumLevelILVarOutputFieldRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarOutputFieldRec -> ShowS
showsPrec :: Int -> MediumLevelILVarOutputFieldRec -> ShowS
$cshow :: MediumLevelILVarOutputFieldRec -> String
show :: MediumLevelILVarOutputFieldRec -> String
$cshowList :: [MediumLevelILVarOutputFieldRec] -> ShowS
showList :: [MediumLevelILVarOutputFieldRec] -> ShowS
Show, MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
(MediumLevelILVarOutputFieldRec
 -> MediumLevelILVarOutputFieldRec -> Bool)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec -> Bool)
-> Eq MediumLevelILVarOutputFieldRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
== :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
$c/= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
/= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
Eq, Eq MediumLevelILVarOutputFieldRec
Eq MediumLevelILVarOutputFieldRec =>
(MediumLevelILVarOutputFieldRec
 -> MediumLevelILVarOutputFieldRec -> Ordering)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec -> Bool)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec -> Bool)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec -> Bool)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec -> Bool)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec)
-> (MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec
    -> MediumLevelILVarOutputFieldRec)
-> Ord MediumLevelILVarOutputFieldRec
MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Ordering
MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> MediumLevelILVarOutputFieldRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Ordering
compare :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Ordering
$c< :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
< :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
$c<= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
<= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
$c> :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
> :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
$c>= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
>= :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> Bool
$cmax :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> MediumLevelILVarOutputFieldRec
max :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> MediumLevelILVarOutputFieldRec
$cmin :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> MediumLevelILVarOutputFieldRec
min :: MediumLevelILVarOutputFieldRec
-> MediumLevelILVarOutputFieldRec -> MediumLevelILVarOutputFieldRec
Ord)

data MediumLevelILStoreOutputRec = MediumLevelILStoreOutputRec
  { MediumLevelILStoreOutputRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILStoreOutputRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILStoreOutputRec -> ShowS
[MediumLevelILStoreOutputRec] -> ShowS
MediumLevelILStoreOutputRec -> String
(Int -> MediumLevelILStoreOutputRec -> ShowS)
-> (MediumLevelILStoreOutputRec -> String)
-> ([MediumLevelILStoreOutputRec] -> ShowS)
-> Show MediumLevelILStoreOutputRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILStoreOutputRec -> ShowS
showsPrec :: Int -> MediumLevelILStoreOutputRec -> ShowS
$cshow :: MediumLevelILStoreOutputRec -> String
show :: MediumLevelILStoreOutputRec -> String
$cshowList :: [MediumLevelILStoreOutputRec] -> ShowS
showList :: [MediumLevelILStoreOutputRec] -> ShowS
Show, MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
(MediumLevelILStoreOutputRec
 -> MediumLevelILStoreOutputRec -> Bool)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> Bool)
-> Eq MediumLevelILStoreOutputRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
== :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
$c/= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
/= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
Eq, Eq MediumLevelILStoreOutputRec
Eq MediumLevelILStoreOutputRec =>
(MediumLevelILStoreOutputRec
 -> MediumLevelILStoreOutputRec -> Ordering)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> Bool)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> Bool)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> Bool)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> Bool)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec)
-> (MediumLevelILStoreOutputRec
    -> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec)
-> Ord MediumLevelILStoreOutputRec
MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> Ordering
MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> Ordering
compare :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> Ordering
$c< :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
< :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
$c<= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
<= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
$c> :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
> :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
$c>= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
>= :: MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec -> Bool
$cmax :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec
max :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec
$cmin :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec
min :: MediumLevelILStoreOutputRec
-> MediumLevelILStoreOutputRec -> MediumLevelILStoreOutputRec
Ord)

data MediumLevelILSyscallRec = MediumLevelILSyscallRec
  { MediumLevelILSyscallRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILSyscallRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSyscallRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSyscallRec -> ShowS
[MediumLevelILSyscallRec] -> ShowS
MediumLevelILSyscallRec -> String
(Int -> MediumLevelILSyscallRec -> ShowS)
-> (MediumLevelILSyscallRec -> String)
-> ([MediumLevelILSyscallRec] -> ShowS)
-> Show MediumLevelILSyscallRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSyscallRec -> ShowS
showsPrec :: Int -> MediumLevelILSyscallRec -> ShowS
$cshow :: MediumLevelILSyscallRec -> String
show :: MediumLevelILSyscallRec -> String
$cshowList :: [MediumLevelILSyscallRec] -> ShowS
showList :: [MediumLevelILSyscallRec] -> ShowS
Show, MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
(MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> (MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> Eq MediumLevelILSyscallRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
== :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
$c/= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
/= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
Eq, Eq MediumLevelILSyscallRec
Eq MediumLevelILSyscallRec =>
(MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Ordering)
-> (MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> (MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> (MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> (MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool)
-> (MediumLevelILSyscallRec
    -> MediumLevelILSyscallRec -> MediumLevelILSyscallRec)
-> (MediumLevelILSyscallRec
    -> MediumLevelILSyscallRec -> MediumLevelILSyscallRec)
-> Ord MediumLevelILSyscallRec
MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Ordering
MediumLevelILSyscallRec
-> MediumLevelILSyscallRec -> MediumLevelILSyscallRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Ordering
compare :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Ordering
$c< :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
< :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
$c<= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
<= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
$c> :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
> :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
$c>= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
>= :: MediumLevelILSyscallRec -> MediumLevelILSyscallRec -> Bool
$cmax :: MediumLevelILSyscallRec
-> MediumLevelILSyscallRec -> MediumLevelILSyscallRec
max :: MediumLevelILSyscallRec
-> MediumLevelILSyscallRec -> MediumLevelILSyscallRec
$cmin :: MediumLevelILSyscallRec
-> MediumLevelILSyscallRec -> MediumLevelILSyscallRec
min :: MediumLevelILSyscallRec
-> MediumLevelILSyscallRec -> MediumLevelILSyscallRec
Ord)

data MediumLevelILSyscallUntypedRec = MediumLevelILSyscallUntypedRec
  { MediumLevelILSyscallUntypedRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILSyscallUntypedRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSyscallUntypedRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILSyscallUntypedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSyscallUntypedRec -> ShowS
[MediumLevelILSyscallUntypedRec] -> ShowS
MediumLevelILSyscallUntypedRec -> String
(Int -> MediumLevelILSyscallUntypedRec -> ShowS)
-> (MediumLevelILSyscallUntypedRec -> String)
-> ([MediumLevelILSyscallUntypedRec] -> ShowS)
-> Show MediumLevelILSyscallUntypedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSyscallUntypedRec -> ShowS
showsPrec :: Int -> MediumLevelILSyscallUntypedRec -> ShowS
$cshow :: MediumLevelILSyscallUntypedRec -> String
show :: MediumLevelILSyscallUntypedRec -> String
$cshowList :: [MediumLevelILSyscallUntypedRec] -> ShowS
showList :: [MediumLevelILSyscallUntypedRec] -> ShowS
Show, MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
(MediumLevelILSyscallUntypedRec
 -> MediumLevelILSyscallUntypedRec -> Bool)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec -> Bool)
-> Eq MediumLevelILSyscallUntypedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
== :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
$c/= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
/= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
Eq, Eq MediumLevelILSyscallUntypedRec
Eq MediumLevelILSyscallUntypedRec =>
(MediumLevelILSyscallUntypedRec
 -> MediumLevelILSyscallUntypedRec -> Ordering)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec -> Bool)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec -> Bool)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec -> Bool)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec -> Bool)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec)
-> (MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec
    -> MediumLevelILSyscallUntypedRec)
-> Ord MediumLevelILSyscallUntypedRec
MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Ordering
MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> MediumLevelILSyscallUntypedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Ordering
compare :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Ordering
$c< :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
< :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
$c<= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
<= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
$c> :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
> :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
$c>= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
>= :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> Bool
$cmax :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> MediumLevelILSyscallUntypedRec
max :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> MediumLevelILSyscallUntypedRec
$cmin :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> MediumLevelILSyscallUntypedRec
min :: MediumLevelILSyscallUntypedRec
-> MediumLevelILSyscallUntypedRec -> MediumLevelILSyscallUntypedRec
Ord)

data MediumLevelILTailcallRec = MediumLevelILTailcallRec
  { MediumLevelILTailcallRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILTailcallRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILTailcallRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTailcallRec -> ShowS
[MediumLevelILTailcallRec] -> ShowS
MediumLevelILTailcallRec -> String
(Int -> MediumLevelILTailcallRec -> ShowS)
-> (MediumLevelILTailcallRec -> String)
-> ([MediumLevelILTailcallRec] -> ShowS)
-> Show MediumLevelILTailcallRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTailcallRec -> ShowS
showsPrec :: Int -> MediumLevelILTailcallRec -> ShowS
$cshow :: MediumLevelILTailcallRec -> String
show :: MediumLevelILTailcallRec -> String
$cshowList :: [MediumLevelILTailcallRec] -> ShowS
showList :: [MediumLevelILTailcallRec] -> ShowS
Show, MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
(MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> (MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> Eq MediumLevelILTailcallRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
== :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
$c/= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
/= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
Eq, Eq MediumLevelILTailcallRec
Eq MediumLevelILTailcallRec =>
(MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Ordering)
-> (MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> (MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> (MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> (MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool)
-> (MediumLevelILTailcallRec
    -> MediumLevelILTailcallRec -> MediumLevelILTailcallRec)
-> (MediumLevelILTailcallRec
    -> MediumLevelILTailcallRec -> MediumLevelILTailcallRec)
-> Ord MediumLevelILTailcallRec
MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Ordering
MediumLevelILTailcallRec
-> MediumLevelILTailcallRec -> MediumLevelILTailcallRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Ordering
compare :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Ordering
$c< :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
< :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
$c<= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
<= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
$c> :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
> :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
$c>= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
>= :: MediumLevelILTailcallRec -> MediumLevelILTailcallRec -> Bool
$cmax :: MediumLevelILTailcallRec
-> MediumLevelILTailcallRec -> MediumLevelILTailcallRec
max :: MediumLevelILTailcallRec
-> MediumLevelILTailcallRec -> MediumLevelILTailcallRec
$cmin :: MediumLevelILTailcallRec
-> MediumLevelILTailcallRec -> MediumLevelILTailcallRec
min :: MediumLevelILTailcallRec
-> MediumLevelILTailcallRec -> MediumLevelILTailcallRec
Ord)

data MediumLevelILTailcallUntypedRec = MediumLevelILTailcallUntypedRec
  { MediumLevelILTailcallUntypedRec -> [BNVariable]
output :: [BNVariable],
    MediumLevelILTailcallUntypedRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallUntypedRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILTailcallUntypedRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallUntypedRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTailcallUntypedRec -> ShowS
[MediumLevelILTailcallUntypedRec] -> ShowS
MediumLevelILTailcallUntypedRec -> String
(Int -> MediumLevelILTailcallUntypedRec -> ShowS)
-> (MediumLevelILTailcallUntypedRec -> String)
-> ([MediumLevelILTailcallUntypedRec] -> ShowS)
-> Show MediumLevelILTailcallUntypedRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTailcallUntypedRec -> ShowS
showsPrec :: Int -> MediumLevelILTailcallUntypedRec -> ShowS
$cshow :: MediumLevelILTailcallUntypedRec -> String
show :: MediumLevelILTailcallUntypedRec -> String
$cshowList :: [MediumLevelILTailcallUntypedRec] -> ShowS
showList :: [MediumLevelILTailcallUntypedRec] -> ShowS
Show, MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
(MediumLevelILTailcallUntypedRec
 -> MediumLevelILTailcallUntypedRec -> Bool)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec -> Bool)
-> Eq MediumLevelILTailcallUntypedRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
== :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
$c/= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
/= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
Eq, Eq MediumLevelILTailcallUntypedRec
Eq MediumLevelILTailcallUntypedRec =>
(MediumLevelILTailcallUntypedRec
 -> MediumLevelILTailcallUntypedRec -> Ordering)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec -> Bool)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec -> Bool)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec -> Bool)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec -> Bool)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec)
-> (MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec
    -> MediumLevelILTailcallUntypedRec)
-> Ord MediumLevelILTailcallUntypedRec
MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Ordering
MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Ordering
compare :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Ordering
$c< :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
< :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
$c<= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
<= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
$c> :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
> :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
$c>= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
>= :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec -> Bool
$cmax :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
max :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
$cmin :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
min :: MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
-> MediumLevelILTailcallUntypedRec
Ord)

data MediumLevelILFreeVarSlotRec = MediumLevelILFreeVarSlotRec
  { MediumLevelILFreeVarSlotRec -> BNVariable
dest :: BNVariable,
    MediumLevelILFreeVarSlotRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFreeVarSlotRec -> ShowS
[MediumLevelILFreeVarSlotRec] -> ShowS
MediumLevelILFreeVarSlotRec -> String
(Int -> MediumLevelILFreeVarSlotRec -> ShowS)
-> (MediumLevelILFreeVarSlotRec -> String)
-> ([MediumLevelILFreeVarSlotRec] -> ShowS)
-> Show MediumLevelILFreeVarSlotRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFreeVarSlotRec -> ShowS
showsPrec :: Int -> MediumLevelILFreeVarSlotRec -> ShowS
$cshow :: MediumLevelILFreeVarSlotRec -> String
show :: MediumLevelILFreeVarSlotRec -> String
$cshowList :: [MediumLevelILFreeVarSlotRec] -> ShowS
showList :: [MediumLevelILFreeVarSlotRec] -> ShowS
Show, MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
(MediumLevelILFreeVarSlotRec
 -> MediumLevelILFreeVarSlotRec -> Bool)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> Bool)
-> Eq MediumLevelILFreeVarSlotRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
== :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
$c/= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
/= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
Eq, Eq MediumLevelILFreeVarSlotRec
Eq MediumLevelILFreeVarSlotRec =>
(MediumLevelILFreeVarSlotRec
 -> MediumLevelILFreeVarSlotRec -> Ordering)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> Bool)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> Bool)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> Bool)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> Bool)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec)
-> (MediumLevelILFreeVarSlotRec
    -> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec)
-> Ord MediumLevelILFreeVarSlotRec
MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> Ordering
MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> Ordering
compare :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> Ordering
$c< :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
< :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
$c<= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
<= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
$c> :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
> :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
$c>= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
>= :: MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec -> Bool
$cmax :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec
max :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec
$cmin :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec
min :: MediumLevelILFreeVarSlotRec
-> MediumLevelILFreeVarSlotRec -> MediumLevelILFreeVarSlotRec
Ord)

data MediumLevelILSyscallSsaRec = MediumLevelILSyscallSsaRec
  { MediumLevelILSyscallSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILSyscallSsaRec -> Int
outputDestMemory :: Int,
    MediumLevelILSyscallSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSyscallSsaRec -> Int
srcMemory :: Int,
    MediumLevelILSyscallSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSyscallSsaRec -> ShowS
[MediumLevelILSyscallSsaRec] -> ShowS
MediumLevelILSyscallSsaRec -> String
(Int -> MediumLevelILSyscallSsaRec -> ShowS)
-> (MediumLevelILSyscallSsaRec -> String)
-> ([MediumLevelILSyscallSsaRec] -> ShowS)
-> Show MediumLevelILSyscallSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSyscallSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILSyscallSsaRec -> ShowS
$cshow :: MediumLevelILSyscallSsaRec -> String
show :: MediumLevelILSyscallSsaRec -> String
$cshowList :: [MediumLevelILSyscallSsaRec] -> ShowS
showList :: [MediumLevelILSyscallSsaRec] -> ShowS
Show, MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
(MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> Bool)
-> Eq MediumLevelILSyscallSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
== :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
$c/= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
/= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
Eq, Eq MediumLevelILSyscallSsaRec
Eq MediumLevelILSyscallSsaRec =>
(MediumLevelILSyscallSsaRec
 -> MediumLevelILSyscallSsaRec -> Ordering)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> Bool)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> Bool)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> Bool)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> Bool)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec)
-> (MediumLevelILSyscallSsaRec
    -> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec)
-> Ord MediumLevelILSyscallSsaRec
MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> Ordering
MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> Ordering
compare :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> Ordering
$c< :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
< :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
$c<= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
<= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
$c> :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
> :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
$c>= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
>= :: MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec -> Bool
$cmax :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec
max :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec
$cmin :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec
min :: MediumLevelILSyscallSsaRec
-> MediumLevelILSyscallSsaRec -> MediumLevelILSyscallSsaRec
Ord)

data MediumLevelILSyscallUntypedSsaRec = MediumLevelILSyscallUntypedSsaRec
  { MediumLevelILSyscallUntypedSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILSyscallUntypedSsaRec -> Int
outputDestMemory :: Int,
    MediumLevelILSyscallUntypedSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILSyscallUntypedSsaRec -> Int
paramsSrcMemory :: Int,
    MediumLevelILSyscallUntypedSsaRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILSyscallUntypedSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILSyscallUntypedSsaRec -> ShowS
[MediumLevelILSyscallUntypedSsaRec] -> ShowS
MediumLevelILSyscallUntypedSsaRec -> String
(Int -> MediumLevelILSyscallUntypedSsaRec -> ShowS)
-> (MediumLevelILSyscallUntypedSsaRec -> String)
-> ([MediumLevelILSyscallUntypedSsaRec] -> ShowS)
-> Show MediumLevelILSyscallUntypedSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSyscallUntypedSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILSyscallUntypedSsaRec -> ShowS
$cshow :: MediumLevelILSyscallUntypedSsaRec -> String
show :: MediumLevelILSyscallUntypedSsaRec -> String
$cshowList :: [MediumLevelILSyscallUntypedSsaRec] -> ShowS
showList :: [MediumLevelILSyscallUntypedSsaRec] -> ShowS
Show, MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
(MediumLevelILSyscallUntypedSsaRec
 -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> Eq MediumLevelILSyscallUntypedSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
== :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
$c/= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
/= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
Eq, Eq MediumLevelILSyscallUntypedSsaRec
Eq MediumLevelILSyscallUntypedSsaRec =>
(MediumLevelILSyscallUntypedSsaRec
 -> MediumLevelILSyscallUntypedSsaRec -> Ordering)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec -> Bool)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec)
-> (MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec
    -> MediumLevelILSyscallUntypedSsaRec)
-> Ord MediumLevelILSyscallUntypedSsaRec
MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Ordering
MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Ordering
compare :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Ordering
$c< :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
< :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
$c<= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
<= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
$c> :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
> :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
$c>= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
>= :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec -> Bool
$cmax :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
max :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
$cmin :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
min :: MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
-> MediumLevelILSyscallUntypedSsaRec
Ord)

data MediumLevelILTailcallUntypedSsaRec = MediumLevelILTailcallUntypedSsaRec
  { MediumLevelILTailcallUntypedSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILTailcallUntypedSsaRec -> Int
outputDestMemory :: Int,
    MediumLevelILTailcallUntypedSsaRec -> MediumLevelILSSAInstruction
dest :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallUntypedSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILTailcallUntypedSsaRec -> MediumLevelILSSAInstruction
stack :: MediumLevelILSSAInstruction,
    MediumLevelILTailcallUntypedSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILTailcallUntypedSsaRec -> ShowS
[MediumLevelILTailcallUntypedSsaRec] -> ShowS
MediumLevelILTailcallUntypedSsaRec -> String
(Int -> MediumLevelILTailcallUntypedSsaRec -> ShowS)
-> (MediumLevelILTailcallUntypedSsaRec -> String)
-> ([MediumLevelILTailcallUntypedSsaRec] -> ShowS)
-> Show MediumLevelILTailcallUntypedSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILTailcallUntypedSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILTailcallUntypedSsaRec -> ShowS
$cshow :: MediumLevelILTailcallUntypedSsaRec -> String
show :: MediumLevelILTailcallUntypedSsaRec -> String
$cshowList :: [MediumLevelILTailcallUntypedSsaRec] -> ShowS
showList :: [MediumLevelILTailcallUntypedSsaRec] -> ShowS
Show, MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
(MediumLevelILTailcallUntypedSsaRec
 -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> Eq MediumLevelILTailcallUntypedSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
== :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
$c/= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
/= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
Eq, Eq MediumLevelILTailcallUntypedSsaRec
Eq MediumLevelILTailcallUntypedSsaRec =>
(MediumLevelILTailcallUntypedSsaRec
 -> MediumLevelILTailcallUntypedSsaRec -> Ordering)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec -> Bool)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec)
-> (MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec
    -> MediumLevelILTailcallUntypedSsaRec)
-> Ord MediumLevelILTailcallUntypedSsaRec
MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Ordering
MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Ordering
compare :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Ordering
$c< :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
< :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
$c<= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
<= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
$c> :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
> :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
$c>= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
>= :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec -> Bool
$cmax :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
max :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
$cmin :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
min :: MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
-> MediumLevelILTailcallUntypedSsaRec
Ord)

data MediumLevelILMemoryIntrinsicOutputSsaRec = MediumLevelILMemoryIntrinsicOutputSsaRec
  { MediumLevelILMemoryIntrinsicOutputSsaRec -> Int
destMemory :: Int,
    MediumLevelILMemoryIntrinsicOutputSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILMemoryIntrinsicOutputSsaRec
-> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMemoryIntrinsicOutputSsaRec -> ShowS
[MediumLevelILMemoryIntrinsicOutputSsaRec] -> ShowS
MediumLevelILMemoryIntrinsicOutputSsaRec -> String
(Int -> MediumLevelILMemoryIntrinsicOutputSsaRec -> ShowS)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec -> String)
-> ([MediumLevelILMemoryIntrinsicOutputSsaRec] -> ShowS)
-> Show MediumLevelILMemoryIntrinsicOutputSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMemoryIntrinsicOutputSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILMemoryIntrinsicOutputSsaRec -> ShowS
$cshow :: MediumLevelILMemoryIntrinsicOutputSsaRec -> String
show :: MediumLevelILMemoryIntrinsicOutputSsaRec -> String
$cshowList :: [MediumLevelILMemoryIntrinsicOutputSsaRec] -> ShowS
showList :: [MediumLevelILMemoryIntrinsicOutputSsaRec] -> ShowS
Show, MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
(MediumLevelILMemoryIntrinsicOutputSsaRec
 -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> Eq MediumLevelILMemoryIntrinsicOutputSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
== :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
$c/= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
/= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
Eq, Eq MediumLevelILMemoryIntrinsicOutputSsaRec
Eq MediumLevelILMemoryIntrinsicOutputSsaRec =>
(MediumLevelILMemoryIntrinsicOutputSsaRec
 -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Ordering)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec)
-> (MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec
    -> MediumLevelILMemoryIntrinsicOutputSsaRec)
-> Ord MediumLevelILMemoryIntrinsicOutputSsaRec
MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Ordering
MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Ordering
compare :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Ordering
$c< :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
< :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
$c<= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
<= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
$c> :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
> :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
$c>= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
>= :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec -> Bool
$cmax :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
max :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
$cmin :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
min :: MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
-> MediumLevelILMemoryIntrinsicOutputSsaRec
Ord)

data MediumLevelILMemoryIntrinsicSsaRec = MediumLevelILMemoryIntrinsicSsaRec
  { MediumLevelILMemoryIntrinsicSsaRec -> [BNSSAVariable]
output :: [BNSSAVariable],
    MediumLevelILMemoryIntrinsicSsaRec -> Int
destMemory :: Int,
    MediumLevelILMemoryIntrinsicSsaRec -> ILIntrinsic
intrinsic :: ILIntrinsic,
    MediumLevelILMemoryIntrinsicSsaRec -> [MediumLevelILSSAInstruction]
params :: [MediumLevelILSSAInstruction],
    MediumLevelILMemoryIntrinsicSsaRec -> Int
srcMemory :: Int,
    MediumLevelILMemoryIntrinsicSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMemoryIntrinsicSsaRec -> ShowS
[MediumLevelILMemoryIntrinsicSsaRec] -> ShowS
MediumLevelILMemoryIntrinsicSsaRec -> String
(Int -> MediumLevelILMemoryIntrinsicSsaRec -> ShowS)
-> (MediumLevelILMemoryIntrinsicSsaRec -> String)
-> ([MediumLevelILMemoryIntrinsicSsaRec] -> ShowS)
-> Show MediumLevelILMemoryIntrinsicSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMemoryIntrinsicSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILMemoryIntrinsicSsaRec -> ShowS
$cshow :: MediumLevelILMemoryIntrinsicSsaRec -> String
show :: MediumLevelILMemoryIntrinsicSsaRec -> String
$cshowList :: [MediumLevelILMemoryIntrinsicSsaRec] -> ShowS
showList :: [MediumLevelILMemoryIntrinsicSsaRec] -> ShowS
Show, MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
(MediumLevelILMemoryIntrinsicSsaRec
 -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> Eq MediumLevelILMemoryIntrinsicSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
== :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
$c/= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
/= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
Eq, Eq MediumLevelILMemoryIntrinsicSsaRec
Eq MediumLevelILMemoryIntrinsicSsaRec =>
(MediumLevelILMemoryIntrinsicSsaRec
 -> MediumLevelILMemoryIntrinsicSsaRec -> Ordering)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec -> Bool)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec)
-> (MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec
    -> MediumLevelILMemoryIntrinsicSsaRec)
-> Ord MediumLevelILMemoryIntrinsicSsaRec
MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Ordering
MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Ordering
compare :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Ordering
$c< :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
< :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
$c<= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
<= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
$c> :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
> :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
$c>= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
>= :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec -> Bool
$cmax :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
max :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
$cmin :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
min :: MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
-> MediumLevelILMemoryIntrinsicSsaRec
Ord)

data MediumLevelILFreeVarSlotSsaRec = MediumLevelILFreeVarSlotSsaRec
  { MediumLevelILFreeVarSlotSsaRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILFreeVarSlotSsaRec -> BNSSAVariable
prev :: BNSSAVariable,
    MediumLevelILFreeVarSlotSsaRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILFreeVarSlotSsaRec -> ShowS
[MediumLevelILFreeVarSlotSsaRec] -> ShowS
MediumLevelILFreeVarSlotSsaRec -> String
(Int -> MediumLevelILFreeVarSlotSsaRec -> ShowS)
-> (MediumLevelILFreeVarSlotSsaRec -> String)
-> ([MediumLevelILFreeVarSlotSsaRec] -> ShowS)
-> Show MediumLevelILFreeVarSlotSsaRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILFreeVarSlotSsaRec -> ShowS
showsPrec :: Int -> MediumLevelILFreeVarSlotSsaRec -> ShowS
$cshow :: MediumLevelILFreeVarSlotSsaRec -> String
show :: MediumLevelILFreeVarSlotSsaRec -> String
$cshowList :: [MediumLevelILFreeVarSlotSsaRec] -> ShowS
showList :: [MediumLevelILFreeVarSlotSsaRec] -> ShowS
Show, MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
(MediumLevelILFreeVarSlotSsaRec
 -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> Eq MediumLevelILFreeVarSlotSsaRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
== :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
$c/= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
/= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
Eq, Eq MediumLevelILFreeVarSlotSsaRec
Eq MediumLevelILFreeVarSlotSsaRec =>
(MediumLevelILFreeVarSlotSsaRec
 -> MediumLevelILFreeVarSlotSsaRec -> Ordering)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec -> Bool)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec)
-> (MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec
    -> MediumLevelILFreeVarSlotSsaRec)
-> Ord MediumLevelILFreeVarSlotSsaRec
MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Ordering
MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> MediumLevelILFreeVarSlotSsaRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Ordering
compare :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Ordering
$c< :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
< :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
$c<= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
<= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
$c> :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
> :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
$c>= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
>= :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> Bool
$cmax :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> MediumLevelILFreeVarSlotSsaRec
max :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> MediumLevelILFreeVarSlotSsaRec
$cmin :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> MediumLevelILFreeVarSlotSsaRec
min :: MediumLevelILFreeVarSlotSsaRec
-> MediumLevelILFreeVarSlotSsaRec -> MediumLevelILFreeVarSlotSsaRec
Ord)

data MediumLevelILVarPhiRec = MediumLevelILVarPhiRec
  { MediumLevelILVarPhiRec -> BNSSAVariable
dest :: BNSSAVariable,
    MediumLevelILVarPhiRec -> [BNSSAVariable]
src :: [BNSSAVariable],
    MediumLevelILVarPhiRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILVarPhiRec -> ShowS
[MediumLevelILVarPhiRec] -> ShowS
MediumLevelILVarPhiRec -> String
(Int -> MediumLevelILVarPhiRec -> ShowS)
-> (MediumLevelILVarPhiRec -> String)
-> ([MediumLevelILVarPhiRec] -> ShowS)
-> Show MediumLevelILVarPhiRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILVarPhiRec -> ShowS
showsPrec :: Int -> MediumLevelILVarPhiRec -> ShowS
$cshow :: MediumLevelILVarPhiRec -> String
show :: MediumLevelILVarPhiRec -> String
$cshowList :: [MediumLevelILVarPhiRec] -> ShowS
showList :: [MediumLevelILVarPhiRec] -> ShowS
Show, MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
(MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> (MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> Eq MediumLevelILVarPhiRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
== :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
$c/= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
/= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
Eq, Eq MediumLevelILVarPhiRec
Eq MediumLevelILVarPhiRec =>
(MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Ordering)
-> (MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> (MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> (MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> (MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool)
-> (MediumLevelILVarPhiRec
    -> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec)
-> (MediumLevelILVarPhiRec
    -> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec)
-> Ord MediumLevelILVarPhiRec
MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Ordering
MediumLevelILVarPhiRec
-> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Ordering
compare :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Ordering
$c< :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
< :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
$c<= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
<= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
$c> :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
> :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
$c>= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
>= :: MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec -> Bool
$cmax :: MediumLevelILVarPhiRec
-> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec
max :: MediumLevelILVarPhiRec
-> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec
$cmin :: MediumLevelILVarPhiRec
-> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec
min :: MediumLevelILVarPhiRec
-> MediumLevelILVarPhiRec -> MediumLevelILVarPhiRec
Ord)

data MediumLevelILMemPhiRec = MediumLevelILMemPhiRec
  { MediumLevelILMemPhiRec -> Int
destMemory :: Int,
    MediumLevelILMemPhiRec -> [Int]
srcMemory :: [Int],
    MediumLevelILMemPhiRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMemPhiRec -> ShowS
[MediumLevelILMemPhiRec] -> ShowS
MediumLevelILMemPhiRec -> String
(Int -> MediumLevelILMemPhiRec -> ShowS)
-> (MediumLevelILMemPhiRec -> String)
-> ([MediumLevelILMemPhiRec] -> ShowS)
-> Show MediumLevelILMemPhiRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMemPhiRec -> ShowS
showsPrec :: Int -> MediumLevelILMemPhiRec -> ShowS
$cshow :: MediumLevelILMemPhiRec -> String
show :: MediumLevelILMemPhiRec -> String
$cshowList :: [MediumLevelILMemPhiRec] -> ShowS
showList :: [MediumLevelILMemPhiRec] -> ShowS
Show, MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
(MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> (MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> Eq MediumLevelILMemPhiRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
== :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
$c/= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
/= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
Eq, Eq MediumLevelILMemPhiRec
Eq MediumLevelILMemPhiRec =>
(MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Ordering)
-> (MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> (MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> (MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> (MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool)
-> (MediumLevelILMemPhiRec
    -> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec)
-> (MediumLevelILMemPhiRec
    -> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec)
-> Ord MediumLevelILMemPhiRec
MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Ordering
MediumLevelILMemPhiRec
-> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Ordering
compare :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Ordering
$c< :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
< :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
$c<= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
<= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
$c> :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
> :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
$c>= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
>= :: MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec -> Bool
$cmax :: MediumLevelILMemPhiRec
-> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec
max :: MediumLevelILMemPhiRec
-> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec
$cmin :: MediumLevelILMemPhiRec
-> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec
min :: MediumLevelILMemPhiRec
-> MediumLevelILMemPhiRec -> MediumLevelILMemPhiRec
Ord)

data MediumLevelILBlockToExpandRec = MediumLevelILBlockToExpandRec
  { MediumLevelILBlockToExpandRec -> [MediumLevelILSSAInstruction]
exprs :: [MediumLevelILSSAInstruction],
    MediumLevelILBlockToExpandRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILBlockToExpandRec -> ShowS
[MediumLevelILBlockToExpandRec] -> ShowS
MediumLevelILBlockToExpandRec -> String
(Int -> MediumLevelILBlockToExpandRec -> ShowS)
-> (MediumLevelILBlockToExpandRec -> String)
-> ([MediumLevelILBlockToExpandRec] -> ShowS)
-> Show MediumLevelILBlockToExpandRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILBlockToExpandRec -> ShowS
showsPrec :: Int -> MediumLevelILBlockToExpandRec -> ShowS
$cshow :: MediumLevelILBlockToExpandRec -> String
show :: MediumLevelILBlockToExpandRec -> String
$cshowList :: [MediumLevelILBlockToExpandRec] -> ShowS
showList :: [MediumLevelILBlockToExpandRec] -> ShowS
Show, MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
(MediumLevelILBlockToExpandRec
 -> MediumLevelILBlockToExpandRec -> Bool)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> Bool)
-> Eq MediumLevelILBlockToExpandRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
== :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
$c/= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
/= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
Eq, Eq MediumLevelILBlockToExpandRec
Eq MediumLevelILBlockToExpandRec =>
(MediumLevelILBlockToExpandRec
 -> MediumLevelILBlockToExpandRec -> Ordering)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> Bool)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> Bool)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> Bool)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> Bool)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec)
-> (MediumLevelILBlockToExpandRec
    -> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec)
-> Ord MediumLevelILBlockToExpandRec
MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Ordering
MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Ordering
compare :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Ordering
$c< :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
< :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
$c<= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
<= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
$c> :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
> :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
$c>= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
>= :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> Bool
$cmax :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec
max :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec
$cmin :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec
min :: MediumLevelILBlockToExpandRec
-> MediumLevelILBlockToExpandRec -> MediumLevelILBlockToExpandRec
Ord)

data MediumLevelILBswapRec = MediumLevelILBswapRec
  { MediumLevelILBswapRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILBswapRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILBswapRec -> ShowS
[MediumLevelILBswapRec] -> ShowS
MediumLevelILBswapRec -> String
(Int -> MediumLevelILBswapRec -> ShowS)
-> (MediumLevelILBswapRec -> String)
-> ([MediumLevelILBswapRec] -> ShowS)
-> Show MediumLevelILBswapRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILBswapRec -> ShowS
showsPrec :: Int -> MediumLevelILBswapRec -> ShowS
$cshow :: MediumLevelILBswapRec -> String
show :: MediumLevelILBswapRec -> String
$cshowList :: [MediumLevelILBswapRec] -> ShowS
showList :: [MediumLevelILBswapRec] -> ShowS
Show, MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
(MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> (MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> Eq MediumLevelILBswapRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
== :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
$c/= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
/= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
Eq, Eq MediumLevelILBswapRec
Eq MediumLevelILBswapRec =>
(MediumLevelILBswapRec -> MediumLevelILBswapRec -> Ordering)
-> (MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> (MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> (MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> (MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool)
-> (MediumLevelILBswapRec
    -> MediumLevelILBswapRec -> MediumLevelILBswapRec)
-> (MediumLevelILBswapRec
    -> MediumLevelILBswapRec -> MediumLevelILBswapRec)
-> Ord MediumLevelILBswapRec
MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
MediumLevelILBswapRec -> MediumLevelILBswapRec -> Ordering
MediumLevelILBswapRec
-> MediumLevelILBswapRec -> MediumLevelILBswapRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Ordering
compare :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Ordering
$c< :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
< :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
$c<= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
<= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
$c> :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
> :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
$c>= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
>= :: MediumLevelILBswapRec -> MediumLevelILBswapRec -> Bool
$cmax :: MediumLevelILBswapRec
-> MediumLevelILBswapRec -> MediumLevelILBswapRec
max :: MediumLevelILBswapRec
-> MediumLevelILBswapRec -> MediumLevelILBswapRec
$cmin :: MediumLevelILBswapRec
-> MediumLevelILBswapRec -> MediumLevelILBswapRec
min :: MediumLevelILBswapRec
-> MediumLevelILBswapRec -> MediumLevelILBswapRec
Ord)

data MediumLevelILPopcntRec = MediumLevelILPopcntRec
  { MediumLevelILPopcntRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILPopcntRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILPopcntRec -> ShowS
[MediumLevelILPopcntRec] -> ShowS
MediumLevelILPopcntRec -> String
(Int -> MediumLevelILPopcntRec -> ShowS)
-> (MediumLevelILPopcntRec -> String)
-> ([MediumLevelILPopcntRec] -> ShowS)
-> Show MediumLevelILPopcntRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILPopcntRec -> ShowS
showsPrec :: Int -> MediumLevelILPopcntRec -> ShowS
$cshow :: MediumLevelILPopcntRec -> String
show :: MediumLevelILPopcntRec -> String
$cshowList :: [MediumLevelILPopcntRec] -> ShowS
showList :: [MediumLevelILPopcntRec] -> ShowS
Show, MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
(MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> (MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> Eq MediumLevelILPopcntRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
== :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
$c/= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
/= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
Eq, Eq MediumLevelILPopcntRec
Eq MediumLevelILPopcntRec =>
(MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Ordering)
-> (MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> (MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> (MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> (MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool)
-> (MediumLevelILPopcntRec
    -> MediumLevelILPopcntRec -> MediumLevelILPopcntRec)
-> (MediumLevelILPopcntRec
    -> MediumLevelILPopcntRec -> MediumLevelILPopcntRec)
-> Ord MediumLevelILPopcntRec
MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Ordering
MediumLevelILPopcntRec
-> MediumLevelILPopcntRec -> MediumLevelILPopcntRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Ordering
compare :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Ordering
$c< :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
< :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
$c<= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
<= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
$c> :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
> :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
$c>= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
>= :: MediumLevelILPopcntRec -> MediumLevelILPopcntRec -> Bool
$cmax :: MediumLevelILPopcntRec
-> MediumLevelILPopcntRec -> MediumLevelILPopcntRec
max :: MediumLevelILPopcntRec
-> MediumLevelILPopcntRec -> MediumLevelILPopcntRec
$cmin :: MediumLevelILPopcntRec
-> MediumLevelILPopcntRec -> MediumLevelILPopcntRec
min :: MediumLevelILPopcntRec
-> MediumLevelILPopcntRec -> MediumLevelILPopcntRec
Ord)

data MediumLevelILClzRec = MediumLevelILClzRec
  { MediumLevelILClzRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILClzRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILClzRec -> ShowS
[MediumLevelILClzRec] -> ShowS
MediumLevelILClzRec -> String
(Int -> MediumLevelILClzRec -> ShowS)
-> (MediumLevelILClzRec -> String)
-> ([MediumLevelILClzRec] -> ShowS)
-> Show MediumLevelILClzRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILClzRec -> ShowS
showsPrec :: Int -> MediumLevelILClzRec -> ShowS
$cshow :: MediumLevelILClzRec -> String
show :: MediumLevelILClzRec -> String
$cshowList :: [MediumLevelILClzRec] -> ShowS
showList :: [MediumLevelILClzRec] -> ShowS
Show, MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
(MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> (MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> Eq MediumLevelILClzRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
== :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
$c/= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
/= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
Eq, Eq MediumLevelILClzRec
Eq MediumLevelILClzRec =>
(MediumLevelILClzRec -> MediumLevelILClzRec -> Ordering)
-> (MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> (MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> (MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> (MediumLevelILClzRec -> MediumLevelILClzRec -> Bool)
-> (MediumLevelILClzRec
    -> MediumLevelILClzRec -> MediumLevelILClzRec)
-> (MediumLevelILClzRec
    -> MediumLevelILClzRec -> MediumLevelILClzRec)
-> Ord MediumLevelILClzRec
MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
MediumLevelILClzRec -> MediumLevelILClzRec -> Ordering
MediumLevelILClzRec -> MediumLevelILClzRec -> MediumLevelILClzRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILClzRec -> MediumLevelILClzRec -> Ordering
compare :: MediumLevelILClzRec -> MediumLevelILClzRec -> Ordering
$c< :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
< :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
$c<= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
<= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
$c> :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
> :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
$c>= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
>= :: MediumLevelILClzRec -> MediumLevelILClzRec -> Bool
$cmax :: MediumLevelILClzRec -> MediumLevelILClzRec -> MediumLevelILClzRec
max :: MediumLevelILClzRec -> MediumLevelILClzRec -> MediumLevelILClzRec
$cmin :: MediumLevelILClzRec -> MediumLevelILClzRec -> MediumLevelILClzRec
min :: MediumLevelILClzRec -> MediumLevelILClzRec -> MediumLevelILClzRec
Ord)

data MediumLevelILCtzRec = MediumLevelILCtzRec
  { MediumLevelILCtzRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILCtzRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILCtzRec -> ShowS
[MediumLevelILCtzRec] -> ShowS
MediumLevelILCtzRec -> String
(Int -> MediumLevelILCtzRec -> ShowS)
-> (MediumLevelILCtzRec -> String)
-> ([MediumLevelILCtzRec] -> ShowS)
-> Show MediumLevelILCtzRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILCtzRec -> ShowS
showsPrec :: Int -> MediumLevelILCtzRec -> ShowS
$cshow :: MediumLevelILCtzRec -> String
show :: MediumLevelILCtzRec -> String
$cshowList :: [MediumLevelILCtzRec] -> ShowS
showList :: [MediumLevelILCtzRec] -> ShowS
Show, MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
(MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> (MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> Eq MediumLevelILCtzRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
== :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
$c/= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
/= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
Eq, Eq MediumLevelILCtzRec
Eq MediumLevelILCtzRec =>
(MediumLevelILCtzRec -> MediumLevelILCtzRec -> Ordering)
-> (MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> (MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> (MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> (MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool)
-> (MediumLevelILCtzRec
    -> MediumLevelILCtzRec -> MediumLevelILCtzRec)
-> (MediumLevelILCtzRec
    -> MediumLevelILCtzRec -> MediumLevelILCtzRec)
-> Ord MediumLevelILCtzRec
MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
MediumLevelILCtzRec -> MediumLevelILCtzRec -> Ordering
MediumLevelILCtzRec -> MediumLevelILCtzRec -> MediumLevelILCtzRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Ordering
compare :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Ordering
$c< :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
< :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
$c<= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
<= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
$c> :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
> :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
$c>= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
>= :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> Bool
$cmax :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> MediumLevelILCtzRec
max :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> MediumLevelILCtzRec
$cmin :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> MediumLevelILCtzRec
min :: MediumLevelILCtzRec -> MediumLevelILCtzRec -> MediumLevelILCtzRec
Ord)

data MediumLevelILRbitRec = MediumLevelILRbitRec
  { MediumLevelILRbitRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILRbitRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILRbitRec -> ShowS
[MediumLevelILRbitRec] -> ShowS
MediumLevelILRbitRec -> String
(Int -> MediumLevelILRbitRec -> ShowS)
-> (MediumLevelILRbitRec -> String)
-> ([MediumLevelILRbitRec] -> ShowS)
-> Show MediumLevelILRbitRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILRbitRec -> ShowS
showsPrec :: Int -> MediumLevelILRbitRec -> ShowS
$cshow :: MediumLevelILRbitRec -> String
show :: MediumLevelILRbitRec -> String
$cshowList :: [MediumLevelILRbitRec] -> ShowS
showList :: [MediumLevelILRbitRec] -> ShowS
Show, MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
(MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> (MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> Eq MediumLevelILRbitRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
== :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
$c/= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
/= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
Eq, Eq MediumLevelILRbitRec
Eq MediumLevelILRbitRec =>
(MediumLevelILRbitRec -> MediumLevelILRbitRec -> Ordering)
-> (MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> (MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> (MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> (MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool)
-> (MediumLevelILRbitRec
    -> MediumLevelILRbitRec -> MediumLevelILRbitRec)
-> (MediumLevelILRbitRec
    -> MediumLevelILRbitRec -> MediumLevelILRbitRec)
-> Ord MediumLevelILRbitRec
MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
MediumLevelILRbitRec -> MediumLevelILRbitRec -> Ordering
MediumLevelILRbitRec
-> MediumLevelILRbitRec -> MediumLevelILRbitRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Ordering
compare :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Ordering
$c< :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
< :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
$c<= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
<= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
$c> :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
> :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
$c>= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
>= :: MediumLevelILRbitRec -> MediumLevelILRbitRec -> Bool
$cmax :: MediumLevelILRbitRec
-> MediumLevelILRbitRec -> MediumLevelILRbitRec
max :: MediumLevelILRbitRec
-> MediumLevelILRbitRec -> MediumLevelILRbitRec
$cmin :: MediumLevelILRbitRec
-> MediumLevelILRbitRec -> MediumLevelILRbitRec
min :: MediumLevelILRbitRec
-> MediumLevelILRbitRec -> MediumLevelILRbitRec
Ord)

data MediumLevelILClsRec = MediumLevelILClsRec
  { MediumLevelILClsRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILClsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILClsRec -> ShowS
[MediumLevelILClsRec] -> ShowS
MediumLevelILClsRec -> String
(Int -> MediumLevelILClsRec -> ShowS)
-> (MediumLevelILClsRec -> String)
-> ([MediumLevelILClsRec] -> ShowS)
-> Show MediumLevelILClsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILClsRec -> ShowS
showsPrec :: Int -> MediumLevelILClsRec -> ShowS
$cshow :: MediumLevelILClsRec -> String
show :: MediumLevelILClsRec -> String
$cshowList :: [MediumLevelILClsRec] -> ShowS
showList :: [MediumLevelILClsRec] -> ShowS
Show, MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
(MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> (MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> Eq MediumLevelILClsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
== :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
$c/= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
/= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
Eq, Eq MediumLevelILClsRec
Eq MediumLevelILClsRec =>
(MediumLevelILClsRec -> MediumLevelILClsRec -> Ordering)
-> (MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> (MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> (MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> (MediumLevelILClsRec -> MediumLevelILClsRec -> Bool)
-> (MediumLevelILClsRec
    -> MediumLevelILClsRec -> MediumLevelILClsRec)
-> (MediumLevelILClsRec
    -> MediumLevelILClsRec -> MediumLevelILClsRec)
-> Ord MediumLevelILClsRec
MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
MediumLevelILClsRec -> MediumLevelILClsRec -> Ordering
MediumLevelILClsRec -> MediumLevelILClsRec -> MediumLevelILClsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILClsRec -> MediumLevelILClsRec -> Ordering
compare :: MediumLevelILClsRec -> MediumLevelILClsRec -> Ordering
$c< :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
< :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
$c<= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
<= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
$c> :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
> :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
$c>= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
>= :: MediumLevelILClsRec -> MediumLevelILClsRec -> Bool
$cmax :: MediumLevelILClsRec -> MediumLevelILClsRec -> MediumLevelILClsRec
max :: MediumLevelILClsRec -> MediumLevelILClsRec -> MediumLevelILClsRec
$cmin :: MediumLevelILClsRec -> MediumLevelILClsRec -> MediumLevelILClsRec
min :: MediumLevelILClsRec -> MediumLevelILClsRec -> MediumLevelILClsRec
Ord)

data MediumLevelILMinsRec = MediumLevelILMinsRec
  { MediumLevelILMinsRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMinsRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMinsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMinsRec -> ShowS
[MediumLevelILMinsRec] -> ShowS
MediumLevelILMinsRec -> String
(Int -> MediumLevelILMinsRec -> ShowS)
-> (MediumLevelILMinsRec -> String)
-> ([MediumLevelILMinsRec] -> ShowS)
-> Show MediumLevelILMinsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMinsRec -> ShowS
showsPrec :: Int -> MediumLevelILMinsRec -> ShowS
$cshow :: MediumLevelILMinsRec -> String
show :: MediumLevelILMinsRec -> String
$cshowList :: [MediumLevelILMinsRec] -> ShowS
showList :: [MediumLevelILMinsRec] -> ShowS
Show, MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
(MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> (MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> Eq MediumLevelILMinsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
== :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
$c/= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
/= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
Eq, Eq MediumLevelILMinsRec
Eq MediumLevelILMinsRec =>
(MediumLevelILMinsRec -> MediumLevelILMinsRec -> Ordering)
-> (MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> (MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> (MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> (MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool)
-> (MediumLevelILMinsRec
    -> MediumLevelILMinsRec -> MediumLevelILMinsRec)
-> (MediumLevelILMinsRec
    -> MediumLevelILMinsRec -> MediumLevelILMinsRec)
-> Ord MediumLevelILMinsRec
MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
MediumLevelILMinsRec -> MediumLevelILMinsRec -> Ordering
MediumLevelILMinsRec
-> MediumLevelILMinsRec -> MediumLevelILMinsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Ordering
compare :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Ordering
$c< :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
< :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
$c<= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
<= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
$c> :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
> :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
$c>= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
>= :: MediumLevelILMinsRec -> MediumLevelILMinsRec -> Bool
$cmax :: MediumLevelILMinsRec
-> MediumLevelILMinsRec -> MediumLevelILMinsRec
max :: MediumLevelILMinsRec
-> MediumLevelILMinsRec -> MediumLevelILMinsRec
$cmin :: MediumLevelILMinsRec
-> MediumLevelILMinsRec -> MediumLevelILMinsRec
min :: MediumLevelILMinsRec
-> MediumLevelILMinsRec -> MediumLevelILMinsRec
Ord)

data MediumLevelILMaxsRec = MediumLevelILMaxsRec
  { MediumLevelILMaxsRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMaxsRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMaxsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMaxsRec -> ShowS
[MediumLevelILMaxsRec] -> ShowS
MediumLevelILMaxsRec -> String
(Int -> MediumLevelILMaxsRec -> ShowS)
-> (MediumLevelILMaxsRec -> String)
-> ([MediumLevelILMaxsRec] -> ShowS)
-> Show MediumLevelILMaxsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMaxsRec -> ShowS
showsPrec :: Int -> MediumLevelILMaxsRec -> ShowS
$cshow :: MediumLevelILMaxsRec -> String
show :: MediumLevelILMaxsRec -> String
$cshowList :: [MediumLevelILMaxsRec] -> ShowS
showList :: [MediumLevelILMaxsRec] -> ShowS
Show, MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
(MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> (MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> Eq MediumLevelILMaxsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
== :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
$c/= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
/= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
Eq, Eq MediumLevelILMaxsRec
Eq MediumLevelILMaxsRec =>
(MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Ordering)
-> (MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> (MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> (MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> (MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool)
-> (MediumLevelILMaxsRec
    -> MediumLevelILMaxsRec -> MediumLevelILMaxsRec)
-> (MediumLevelILMaxsRec
    -> MediumLevelILMaxsRec -> MediumLevelILMaxsRec)
-> Ord MediumLevelILMaxsRec
MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Ordering
MediumLevelILMaxsRec
-> MediumLevelILMaxsRec -> MediumLevelILMaxsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Ordering
compare :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Ordering
$c< :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
< :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
$c<= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
<= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
$c> :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
> :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
$c>= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
>= :: MediumLevelILMaxsRec -> MediumLevelILMaxsRec -> Bool
$cmax :: MediumLevelILMaxsRec
-> MediumLevelILMaxsRec -> MediumLevelILMaxsRec
max :: MediumLevelILMaxsRec
-> MediumLevelILMaxsRec -> MediumLevelILMaxsRec
$cmin :: MediumLevelILMaxsRec
-> MediumLevelILMaxsRec -> MediumLevelILMaxsRec
min :: MediumLevelILMaxsRec
-> MediumLevelILMaxsRec -> MediumLevelILMaxsRec
Ord)

data MediumLevelILMinuRec = MediumLevelILMinuRec
  { MediumLevelILMinuRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMinuRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMinuRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMinuRec -> ShowS
[MediumLevelILMinuRec] -> ShowS
MediumLevelILMinuRec -> String
(Int -> MediumLevelILMinuRec -> ShowS)
-> (MediumLevelILMinuRec -> String)
-> ([MediumLevelILMinuRec] -> ShowS)
-> Show MediumLevelILMinuRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMinuRec -> ShowS
showsPrec :: Int -> MediumLevelILMinuRec -> ShowS
$cshow :: MediumLevelILMinuRec -> String
show :: MediumLevelILMinuRec -> String
$cshowList :: [MediumLevelILMinuRec] -> ShowS
showList :: [MediumLevelILMinuRec] -> ShowS
Show, MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
(MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> (MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> Eq MediumLevelILMinuRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
== :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
$c/= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
/= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
Eq, Eq MediumLevelILMinuRec
Eq MediumLevelILMinuRec =>
(MediumLevelILMinuRec -> MediumLevelILMinuRec -> Ordering)
-> (MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> (MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> (MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> (MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool)
-> (MediumLevelILMinuRec
    -> MediumLevelILMinuRec -> MediumLevelILMinuRec)
-> (MediumLevelILMinuRec
    -> MediumLevelILMinuRec -> MediumLevelILMinuRec)
-> Ord MediumLevelILMinuRec
MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
MediumLevelILMinuRec -> MediumLevelILMinuRec -> Ordering
MediumLevelILMinuRec
-> MediumLevelILMinuRec -> MediumLevelILMinuRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Ordering
compare :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Ordering
$c< :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
< :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
$c<= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
<= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
$c> :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
> :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
$c>= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
>= :: MediumLevelILMinuRec -> MediumLevelILMinuRec -> Bool
$cmax :: MediumLevelILMinuRec
-> MediumLevelILMinuRec -> MediumLevelILMinuRec
max :: MediumLevelILMinuRec
-> MediumLevelILMinuRec -> MediumLevelILMinuRec
$cmin :: MediumLevelILMinuRec
-> MediumLevelILMinuRec -> MediumLevelILMinuRec
min :: MediumLevelILMinuRec
-> MediumLevelILMinuRec -> MediumLevelILMinuRec
Ord)

data MediumLevelILMaxuRec = MediumLevelILMaxuRec
  { MediumLevelILMaxuRec -> MediumLevelILSSAInstruction
left :: MediumLevelILSSAInstruction,
    MediumLevelILMaxuRec -> MediumLevelILSSAInstruction
right :: MediumLevelILSSAInstruction,
    MediumLevelILMaxuRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILMaxuRec -> ShowS
[MediumLevelILMaxuRec] -> ShowS
MediumLevelILMaxuRec -> String
(Int -> MediumLevelILMaxuRec -> ShowS)
-> (MediumLevelILMaxuRec -> String)
-> ([MediumLevelILMaxuRec] -> ShowS)
-> Show MediumLevelILMaxuRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILMaxuRec -> ShowS
showsPrec :: Int -> MediumLevelILMaxuRec -> ShowS
$cshow :: MediumLevelILMaxuRec -> String
show :: MediumLevelILMaxuRec -> String
$cshowList :: [MediumLevelILMaxuRec] -> ShowS
showList :: [MediumLevelILMaxuRec] -> ShowS
Show, MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
(MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> (MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> Eq MediumLevelILMaxuRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
== :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
$c/= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
/= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
Eq, Eq MediumLevelILMaxuRec
Eq MediumLevelILMaxuRec =>
(MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Ordering)
-> (MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> (MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> (MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> (MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool)
-> (MediumLevelILMaxuRec
    -> MediumLevelILMaxuRec -> MediumLevelILMaxuRec)
-> (MediumLevelILMaxuRec
    -> MediumLevelILMaxuRec -> MediumLevelILMaxuRec)
-> Ord MediumLevelILMaxuRec
MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Ordering
MediumLevelILMaxuRec
-> MediumLevelILMaxuRec -> MediumLevelILMaxuRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Ordering
compare :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Ordering
$c< :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
< :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
$c<= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
<= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
$c> :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
> :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
$c>= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
>= :: MediumLevelILMaxuRec -> MediumLevelILMaxuRec -> Bool
$cmax :: MediumLevelILMaxuRec
-> MediumLevelILMaxuRec -> MediumLevelILMaxuRec
max :: MediumLevelILMaxuRec
-> MediumLevelILMaxuRec -> MediumLevelILMaxuRec
$cmin :: MediumLevelILMaxuRec
-> MediumLevelILMaxuRec -> MediumLevelILMaxuRec
min :: MediumLevelILMaxuRec
-> MediumLevelILMaxuRec -> MediumLevelILMaxuRec
Ord)

data MediumLevelILAbsRec = MediumLevelILAbsRec
  { MediumLevelILAbsRec -> MediumLevelILSSAInstruction
src :: MediumLevelILSSAInstruction,
    MediumLevelILAbsRec -> CoreMediumLevelILInstruction
core :: CoreMediumLevelILInstruction
  }
  deriving (Int -> MediumLevelILAbsRec -> ShowS
[MediumLevelILAbsRec] -> ShowS
MediumLevelILAbsRec -> String
(Int -> MediumLevelILAbsRec -> ShowS)
-> (MediumLevelILAbsRec -> String)
-> ([MediumLevelILAbsRec] -> ShowS)
-> Show MediumLevelILAbsRec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILAbsRec -> ShowS
showsPrec :: Int -> MediumLevelILAbsRec -> ShowS
$cshow :: MediumLevelILAbsRec -> String
show :: MediumLevelILAbsRec -> String
$cshowList :: [MediumLevelILAbsRec] -> ShowS
showList :: [MediumLevelILAbsRec] -> ShowS
Show, MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
(MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> (MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> Eq MediumLevelILAbsRec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
== :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
$c/= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
/= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
Eq, Eq MediumLevelILAbsRec
Eq MediumLevelILAbsRec =>
(MediumLevelILAbsRec -> MediumLevelILAbsRec -> Ordering)
-> (MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> (MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> (MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> (MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool)
-> (MediumLevelILAbsRec
    -> MediumLevelILAbsRec -> MediumLevelILAbsRec)
-> (MediumLevelILAbsRec
    -> MediumLevelILAbsRec -> MediumLevelILAbsRec)
-> Ord MediumLevelILAbsRec
MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
MediumLevelILAbsRec -> MediumLevelILAbsRec -> Ordering
MediumLevelILAbsRec -> MediumLevelILAbsRec -> MediumLevelILAbsRec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Ordering
compare :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Ordering
$c< :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
< :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
$c<= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
<= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
$c> :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
> :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
$c>= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
>= :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> Bool
$cmax :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> MediumLevelILAbsRec
max :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> MediumLevelILAbsRec
$cmin :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> MediumLevelILAbsRec
min :: MediumLevelILAbsRec -> MediumLevelILAbsRec -> MediumLevelILAbsRec
Ord)

data Localcall
  = MediumLevelILCallSsa MediumLevelILCallSsaRec
  | MediumLevelILCallUntypedSsa MediumLevelILCallUntypedSsaRec
  deriving (Int -> Localcall -> ShowS
[Localcall] -> ShowS
Localcall -> String
(Int -> Localcall -> ShowS)
-> (Localcall -> String)
-> ([Localcall] -> ShowS)
-> Show Localcall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Localcall -> ShowS
showsPrec :: Int -> Localcall -> ShowS
$cshow :: Localcall -> String
show :: Localcall -> String
$cshowList :: [Localcall] -> ShowS
showList :: [Localcall] -> ShowS
Show, Localcall -> Localcall -> Bool
(Localcall -> Localcall -> Bool)
-> (Localcall -> Localcall -> Bool) -> Eq Localcall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Localcall -> Localcall -> Bool
== :: Localcall -> Localcall -> Bool
$c/= :: Localcall -> Localcall -> Bool
/= :: Localcall -> Localcall -> Bool
Eq, Eq Localcall
Eq Localcall =>
(Localcall -> Localcall -> Ordering)
-> (Localcall -> Localcall -> Bool)
-> (Localcall -> Localcall -> Bool)
-> (Localcall -> Localcall -> Bool)
-> (Localcall -> Localcall -> Bool)
-> (Localcall -> Localcall -> Localcall)
-> (Localcall -> Localcall -> Localcall)
-> Ord Localcall
Localcall -> Localcall -> Bool
Localcall -> Localcall -> Ordering
Localcall -> Localcall -> Localcall
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Localcall -> Localcall -> Ordering
compare :: Localcall -> Localcall -> Ordering
$c< :: Localcall -> Localcall -> Bool
< :: Localcall -> Localcall -> Bool
$c<= :: Localcall -> Localcall -> Bool
<= :: Localcall -> Localcall -> Bool
$c> :: Localcall -> Localcall -> Bool
> :: Localcall -> Localcall -> Bool
$c>= :: Localcall -> Localcall -> Bool
>= :: Localcall -> Localcall -> Bool
$cmax :: Localcall -> Localcall -> Localcall
max :: Localcall -> Localcall -> Localcall
$cmin :: Localcall -> Localcall -> Localcall
min :: Localcall -> Localcall -> Localcall
Ord)

data Constant
  = MediumLevelILConst MediumLevelILConstRec
  | MediumLevelILConstPtr MediumLevelILConstPtrRec
  | MediumLevelILFloatConst MediumLevelILFloatConstRec
  | MediumLevelILImport MediumLevelILImportRec
  | MediumLevelILConstData MediumLevelILConstDataRec
  | MediumLevelILExternPtr MediumLevelILExternPtrRec
  deriving (Int -> Constant -> ShowS
[Constant] -> ShowS
Constant -> String
(Int -> Constant -> ShowS)
-> (Constant -> String) -> ([Constant] -> ShowS) -> Show Constant
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Constant -> ShowS
showsPrec :: Int -> Constant -> ShowS
$cshow :: Constant -> String
show :: Constant -> String
$cshowList :: [Constant] -> ShowS
showList :: [Constant] -> ShowS
Show, Constant -> Constant -> Bool
(Constant -> Constant -> Bool)
-> (Constant -> Constant -> Bool) -> Eq Constant
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Constant -> Constant -> Bool
== :: Constant -> Constant -> Bool
$c/= :: Constant -> Constant -> Bool
/= :: Constant -> Constant -> Bool
Eq, Eq Constant
Eq Constant =>
(Constant -> Constant -> Ordering)
-> (Constant -> Constant -> Bool)
-> (Constant -> Constant -> Bool)
-> (Constant -> Constant -> Bool)
-> (Constant -> Constant -> Bool)
-> (Constant -> Constant -> Constant)
-> (Constant -> Constant -> Constant)
-> Ord Constant
Constant -> Constant -> Bool
Constant -> Constant -> Ordering
Constant -> Constant -> Constant
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Constant -> Constant -> Ordering
compare :: Constant -> Constant -> Ordering
$c< :: Constant -> Constant -> Bool
< :: Constant -> Constant -> Bool
$c<= :: Constant -> Constant -> Bool
<= :: Constant -> Constant -> Bool
$c> :: Constant -> Constant -> Bool
> :: Constant -> Constant -> Bool
$c>= :: Constant -> Constant -> Bool
>= :: Constant -> Constant -> Bool
$cmax :: Constant -> Constant -> Constant
max :: Constant -> Constant -> Constant
$cmin :: Constant -> Constant -> Constant
min :: Constant -> Constant -> Constant
Ord)

data Comparison
  = MediumLevelILCmpE MediumLevelILCmpERec
  | MediumLevelILFcmpE MediumLevelILFcmpERec
  | MediumLevelILCmpNe MediumLevelILCmpNeRec
  | MediumLevelILFcmpNe MediumLevelILFcmpNeRec
  | MediumLevelILFcmpLt MediumLevelILFcmpLtRec
  | MediumLevelILFcmpLe MediumLevelILFcmpLeRec
  | MediumLevelILFcmpGe MediumLevelILFcmpGeRec
  | MediumLevelILFcmpGt MediumLevelILFcmpGtRec
  | MediumLevelILCmpSlt MediumLevelILCmpSltRec
  | MediumLevelILCmpUlt MediumLevelILCmpUltRec
  | MediumLevelILCmpSle MediumLevelILCmpSleRec
  | MediumLevelILCmpUle MediumLevelILCmpUleRec
  | MediumLevelILCmpSge MediumLevelILCmpSgeRec
  | MediumLevelILCmpUge MediumLevelILCmpUgeRec
  | MediumLevelILCmpSgt MediumLevelILCmpSgtRec
  | MediumLevelILCmpUgt MediumLevelILCmpUgtRec
  | MediumLevelILFcmpO MediumLevelILFcmpORec
  | MediumLevelILFcmpUo MediumLevelILFcmpUoRec
  | MediumLevelILTestBit MediumLevelILTestBitRec
  deriving (Int -> Comparison -> ShowS
[Comparison] -> ShowS
Comparison -> String
(Int -> Comparison -> ShowS)
-> (Comparison -> String)
-> ([Comparison] -> ShowS)
-> Show Comparison
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Comparison -> ShowS
showsPrec :: Int -> Comparison -> ShowS
$cshow :: Comparison -> String
show :: Comparison -> String
$cshowList :: [Comparison] -> ShowS
showList :: [Comparison] -> ShowS
Show, Comparison -> Comparison -> Bool
(Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool) -> Eq Comparison
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Comparison -> Comparison -> Bool
== :: Comparison -> Comparison -> Bool
$c/= :: Comparison -> Comparison -> Bool
/= :: Comparison -> Comparison -> Bool
Eq, Eq Comparison
Eq Comparison =>
(Comparison -> Comparison -> Ordering)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Bool)
-> (Comparison -> Comparison -> Comparison)
-> (Comparison -> Comparison -> Comparison)
-> Ord Comparison
Comparison -> Comparison -> Bool
Comparison -> Comparison -> Ordering
Comparison -> Comparison -> Comparison
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Comparison -> Comparison -> Ordering
compare :: Comparison -> Comparison -> Ordering
$c< :: Comparison -> Comparison -> Bool
< :: Comparison -> Comparison -> Bool
$c<= :: Comparison -> Comparison -> Bool
<= :: Comparison -> Comparison -> Bool
$c> :: Comparison -> Comparison -> Bool
> :: Comparison -> Comparison -> Bool
$c>= :: Comparison -> Comparison -> Bool
>= :: Comparison -> Comparison -> Bool
$cmax :: Comparison -> Comparison -> Comparison
max :: Comparison -> Comparison -> Comparison
$cmin :: Comparison -> Comparison -> Comparison
min :: Comparison -> Comparison -> Comparison
Ord)

data Arithmetic
  = MediumLevelILNeg MediumLevelILNegRec
  | MediumLevelILNot MediumLevelILNotRec
  | MediumLevelILSx MediumLevelILSxRec
  | MediumLevelILZx MediumLevelILZxRec
  | MediumLevelILLowPart MediumLevelILLowPartRec
  | MediumLevelILFsqrt MediumLevelILFsqrtRec
  | MediumLevelILFneg MediumLevelILFnegRec
  | MediumLevelILFabs MediumLevelILFabsRec
  | MediumLevelILFloatToInt MediumLevelILFloatToIntRec
  | MediumLevelILIntToFloat MediumLevelILIntToFloatRec
  | MediumLevelILFloatConv MediumLevelILFloatConvRec
  | MediumLevelILRoundToInt MediumLevelILRoundToIntRec
  | MediumLevelILFloor MediumLevelILFloorRec
  | MediumLevelILCeil MediumLevelILCeilRec
  | MediumLevelILFtrunc MediumLevelILFtruncRec
  | MediumLevelILAdd MediumLevelILAddRec
  | MediumLevelILSub MediumLevelILSubRec
  | MediumLevelILAnd MediumLevelILAndRec
  | MediumLevelILOr MediumLevelILOrRec
  | MediumLevelILXor MediumLevelILXorRec
  | MediumLevelILLsl MediumLevelILLslRec
  | MediumLevelILLsr MediumLevelILLsrRec
  | MediumLevelILAsr MediumLevelILAsrRec
  | MediumLevelILRol MediumLevelILRolRec
  | MediumLevelILRor MediumLevelILRorRec
  | MediumLevelILMul MediumLevelILMulRec
  | MediumLevelILDivu MediumLevelILDivuRec
  | MediumLevelILDivs MediumLevelILDivsRec
  | MediumLevelILModu MediumLevelILModuRec
  | MediumLevelILMods MediumLevelILModsRec
  | MediumLevelILAddOverflow MediumLevelILAddOverflowRec
  | MediumLevelILFadd MediumLevelILFaddRec
  | MediumLevelILFsub MediumLevelILFsubRec
  | MediumLevelILFmul MediumLevelILFmulRec
  | MediumLevelILFdiv MediumLevelILFdivRec
  | MediumLevelILBswap MediumLevelILBswapRec
  | MediumLevelILPopcnt MediumLevelILPopcntRec
  | MediumLevelILClz MediumLevelILClzRec
  | MediumLevelILCtz MediumLevelILCtzRec
  | MediumLevelILRbit MediumLevelILRbitRec
  | MediumLevelILCls MediumLevelILClsRec
  | MediumLevelILMins MediumLevelILMinsRec
  | MediumLevelILMaxs MediumLevelILMaxsRec
  | MediumLevelILMinu MediumLevelILMinuRec
  | MediumLevelILMaxu MediumLevelILMaxuRec
  | MediumLevelILAbs MediumLevelILAbsRec
  deriving (Int -> Arithmetic -> ShowS
[Arithmetic] -> ShowS
Arithmetic -> String
(Int -> Arithmetic -> ShowS)
-> (Arithmetic -> String)
-> ([Arithmetic] -> ShowS)
-> Show Arithmetic
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Arithmetic -> ShowS
showsPrec :: Int -> Arithmetic -> ShowS
$cshow :: Arithmetic -> String
show :: Arithmetic -> String
$cshowList :: [Arithmetic] -> ShowS
showList :: [Arithmetic] -> ShowS
Show, Arithmetic -> Arithmetic -> Bool
(Arithmetic -> Arithmetic -> Bool)
-> (Arithmetic -> Arithmetic -> Bool) -> Eq Arithmetic
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Arithmetic -> Arithmetic -> Bool
== :: Arithmetic -> Arithmetic -> Bool
$c/= :: Arithmetic -> Arithmetic -> Bool
/= :: Arithmetic -> Arithmetic -> Bool
Eq, Eq Arithmetic
Eq Arithmetic =>
(Arithmetic -> Arithmetic -> Ordering)
-> (Arithmetic -> Arithmetic -> Bool)
-> (Arithmetic -> Arithmetic -> Bool)
-> (Arithmetic -> Arithmetic -> Bool)
-> (Arithmetic -> Arithmetic -> Bool)
-> (Arithmetic -> Arithmetic -> Arithmetic)
-> (Arithmetic -> Arithmetic -> Arithmetic)
-> Ord Arithmetic
Arithmetic -> Arithmetic -> Bool
Arithmetic -> Arithmetic -> Ordering
Arithmetic -> Arithmetic -> Arithmetic
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Arithmetic -> Arithmetic -> Ordering
compare :: Arithmetic -> Arithmetic -> Ordering
$c< :: Arithmetic -> Arithmetic -> Bool
< :: Arithmetic -> Arithmetic -> Bool
$c<= :: Arithmetic -> Arithmetic -> Bool
<= :: Arithmetic -> Arithmetic -> Bool
$c> :: Arithmetic -> Arithmetic -> Bool
> :: Arithmetic -> Arithmetic -> Bool
$c>= :: Arithmetic -> Arithmetic -> Bool
>= :: Arithmetic -> Arithmetic -> Bool
$cmax :: Arithmetic -> Arithmetic -> Arithmetic
max :: Arithmetic -> Arithmetic -> Arithmetic
$cmin :: Arithmetic -> Arithmetic -> Arithmetic
min :: Arithmetic -> Arithmetic -> Arithmetic
Ord)

data Terminal
  = MediumLevelILNoret MediumLevelILNoretRec
  | MediumLevelILBp MediumLevelILBpRec
  | MediumLevelILJump MediumLevelILJumpRec
  | MediumLevelILGoto MediumLevelILGotoRec
  | MediumLevelILTrap MediumLevelILTrapRec
  | MediumLevelILJumpTo MediumLevelILJumpToRec
  | MediumLevelILIf MediumLevelILIfRec
  deriving (Int -> Terminal -> ShowS
[Terminal] -> ShowS
Terminal -> String
(Int -> Terminal -> ShowS)
-> (Terminal -> String) -> ([Terminal] -> ShowS) -> Show Terminal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Terminal -> ShowS
showsPrec :: Int -> Terminal -> ShowS
$cshow :: Terminal -> String
show :: Terminal -> String
$cshowList :: [Terminal] -> ShowS
showList :: [Terminal] -> ShowS
Show, Terminal -> Terminal -> Bool
(Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Bool) -> Eq Terminal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Terminal -> Terminal -> Bool
== :: Terminal -> Terminal -> Bool
$c/= :: Terminal -> Terminal -> Bool
/= :: Terminal -> Terminal -> Bool
Eq, Eq Terminal
Eq Terminal =>
(Terminal -> Terminal -> Ordering)
-> (Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Bool)
-> (Terminal -> Terminal -> Terminal)
-> (Terminal -> Terminal -> Terminal)
-> Ord Terminal
Terminal -> Terminal -> Bool
Terminal -> Terminal -> Ordering
Terminal -> Terminal -> Terminal
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Terminal -> Terminal -> Ordering
compare :: Terminal -> Terminal -> Ordering
$c< :: Terminal -> Terminal -> Bool
< :: Terminal -> Terminal -> Bool
$c<= :: Terminal -> Terminal -> Bool
<= :: Terminal -> Terminal -> Bool
$c> :: Terminal -> Terminal -> Bool
> :: Terminal -> Terminal -> Bool
$c>= :: Terminal -> Terminal -> Bool
>= :: Terminal -> Terminal -> Bool
$cmax :: Terminal -> Terminal -> Terminal
max :: Terminal -> Terminal -> Terminal
$cmin :: Terminal -> Terminal -> Terminal
min :: Terminal -> Terminal -> Terminal
Ord)

data Syscall
  = MediumLevelILSyscallUntyped MediumLevelILSyscallUntypedRec
  | MediumLevelILSyscallSsa MediumLevelILSyscallSsaRec
  | MediumLevelILSyscall MediumLevelILSyscallRec
  | MediumLevelILSyscallUntypedSsa MediumLevelILSyscallUntypedSsaRec
  deriving (Int -> Syscall -> ShowS
[Syscall] -> ShowS
Syscall -> String
(Int -> Syscall -> ShowS)
-> (Syscall -> String) -> ([Syscall] -> ShowS) -> Show Syscall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Syscall -> ShowS
showsPrec :: Int -> Syscall -> ShowS
$cshow :: Syscall -> String
show :: Syscall -> String
$cshowList :: [Syscall] -> ShowS
showList :: [Syscall] -> ShowS
Show, Syscall -> Syscall -> Bool
(Syscall -> Syscall -> Bool)
-> (Syscall -> Syscall -> Bool) -> Eq Syscall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Syscall -> Syscall -> Bool
== :: Syscall -> Syscall -> Bool
$c/= :: Syscall -> Syscall -> Bool
/= :: Syscall -> Syscall -> Bool
Eq, Eq Syscall
Eq Syscall =>
(Syscall -> Syscall -> Ordering)
-> (Syscall -> Syscall -> Bool)
-> (Syscall -> Syscall -> Bool)
-> (Syscall -> Syscall -> Bool)
-> (Syscall -> Syscall -> Bool)
-> (Syscall -> Syscall -> Syscall)
-> (Syscall -> Syscall -> Syscall)
-> Ord Syscall
Syscall -> Syscall -> Bool
Syscall -> Syscall -> Ordering
Syscall -> Syscall -> Syscall
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Syscall -> Syscall -> Ordering
compare :: Syscall -> Syscall -> Ordering
$c< :: Syscall -> Syscall -> Bool
< :: Syscall -> Syscall -> Bool
$c<= :: Syscall -> Syscall -> Bool
<= :: Syscall -> Syscall -> Bool
$c> :: Syscall -> Syscall -> Bool
> :: Syscall -> Syscall -> Bool
$c>= :: Syscall -> Syscall -> Bool
>= :: Syscall -> Syscall -> Bool
$cmax :: Syscall -> Syscall -> Syscall
max :: Syscall -> Syscall -> Syscall
$cmin :: Syscall -> Syscall -> Syscall
min :: Syscall -> Syscall -> Syscall
Ord)

data Tailcall
  = MediumLevelILTailcallUntyped MediumLevelILTailcallUntypedRec
  | MediumLevelILTailcall MediumLevelILTailcallRec
  | MediumLevelILTailcallSsa MediumLevelILTailcallSsaRec
  | MediumLevelILTailcallUntypedSsa MediumLevelILTailcallUntypedSsaRec
  deriving (Int -> Tailcall -> ShowS
[Tailcall] -> ShowS
Tailcall -> String
(Int -> Tailcall -> ShowS)
-> (Tailcall -> String) -> ([Tailcall] -> ShowS) -> Show Tailcall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tailcall -> ShowS
showsPrec :: Int -> Tailcall -> ShowS
$cshow :: Tailcall -> String
show :: Tailcall -> String
$cshowList :: [Tailcall] -> ShowS
showList :: [Tailcall] -> ShowS
Show, Tailcall -> Tailcall -> Bool
(Tailcall -> Tailcall -> Bool)
-> (Tailcall -> Tailcall -> Bool) -> Eq Tailcall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tailcall -> Tailcall -> Bool
== :: Tailcall -> Tailcall -> Bool
$c/= :: Tailcall -> Tailcall -> Bool
/= :: Tailcall -> Tailcall -> Bool
Eq, Eq Tailcall
Eq Tailcall =>
(Tailcall -> Tailcall -> Ordering)
-> (Tailcall -> Tailcall -> Bool)
-> (Tailcall -> Tailcall -> Bool)
-> (Tailcall -> Tailcall -> Bool)
-> (Tailcall -> Tailcall -> Bool)
-> (Tailcall -> Tailcall -> Tailcall)
-> (Tailcall -> Tailcall -> Tailcall)
-> Ord Tailcall
Tailcall -> Tailcall -> Bool
Tailcall -> Tailcall -> Ordering
Tailcall -> Tailcall -> Tailcall
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Tailcall -> Tailcall -> Ordering
compare :: Tailcall -> Tailcall -> Ordering
$c< :: Tailcall -> Tailcall -> Bool
< :: Tailcall -> Tailcall -> Bool
$c<= :: Tailcall -> Tailcall -> Bool
<= :: Tailcall -> Tailcall -> Bool
$c> :: Tailcall -> Tailcall -> Bool
> :: Tailcall -> Tailcall -> Bool
$c>= :: Tailcall -> Tailcall -> Bool
>= :: Tailcall -> Tailcall -> Bool
$cmax :: Tailcall -> Tailcall -> Tailcall
max :: Tailcall -> Tailcall -> Tailcall
$cmin :: Tailcall -> Tailcall -> Tailcall
min :: Tailcall -> Tailcall -> Tailcall
Ord)

data ControlFlow
  = MediumLevelILRetHint MediumLevelILRetHintRec
  deriving (Int -> ControlFlow -> ShowS
[ControlFlow] -> ShowS
ControlFlow -> String
(Int -> ControlFlow -> ShowS)
-> (ControlFlow -> String)
-> ([ControlFlow] -> ShowS)
-> Show ControlFlow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ControlFlow -> ShowS
showsPrec :: Int -> ControlFlow -> ShowS
$cshow :: ControlFlow -> String
show :: ControlFlow -> String
$cshowList :: [ControlFlow] -> ShowS
showList :: [ControlFlow] -> ShowS
Show, ControlFlow -> ControlFlow -> Bool
(ControlFlow -> ControlFlow -> Bool)
-> (ControlFlow -> ControlFlow -> Bool) -> Eq ControlFlow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ControlFlow -> ControlFlow -> Bool
== :: ControlFlow -> ControlFlow -> Bool
$c/= :: ControlFlow -> ControlFlow -> Bool
/= :: ControlFlow -> ControlFlow -> Bool
Eq, Eq ControlFlow
Eq ControlFlow =>
(ControlFlow -> ControlFlow -> Ordering)
-> (ControlFlow -> ControlFlow -> Bool)
-> (ControlFlow -> ControlFlow -> Bool)
-> (ControlFlow -> ControlFlow -> Bool)
-> (ControlFlow -> ControlFlow -> Bool)
-> (ControlFlow -> ControlFlow -> ControlFlow)
-> (ControlFlow -> ControlFlow -> ControlFlow)
-> Ord ControlFlow
ControlFlow -> ControlFlow -> Bool
ControlFlow -> ControlFlow -> Ordering
ControlFlow -> ControlFlow -> ControlFlow
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ControlFlow -> ControlFlow -> Ordering
compare :: ControlFlow -> ControlFlow -> Ordering
$c< :: ControlFlow -> ControlFlow -> Bool
< :: ControlFlow -> ControlFlow -> Bool
$c<= :: ControlFlow -> ControlFlow -> Bool
<= :: ControlFlow -> ControlFlow -> Bool
$c> :: ControlFlow -> ControlFlow -> Bool
> :: ControlFlow -> ControlFlow -> Bool
$c>= :: ControlFlow -> ControlFlow -> Bool
>= :: ControlFlow -> ControlFlow -> Bool
$cmax :: ControlFlow -> ControlFlow -> ControlFlow
max :: ControlFlow -> ControlFlow -> ControlFlow
$cmin :: ControlFlow -> ControlFlow -> ControlFlow
min :: ControlFlow -> ControlFlow -> ControlFlow
Ord)

data Return
  = MediumLevelILRet MediumLevelILRetRec
  deriving (Int -> Return -> ShowS
[Return] -> ShowS
Return -> String
(Int -> Return -> ShowS)
-> (Return -> String) -> ([Return] -> ShowS) -> Show Return
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Return -> ShowS
showsPrec :: Int -> Return -> ShowS
$cshow :: Return -> String
show :: Return -> String
$cshowList :: [Return] -> ShowS
showList :: [Return] -> ShowS
Show, Return -> Return -> Bool
(Return -> Return -> Bool)
-> (Return -> Return -> Bool) -> Eq Return
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Return -> Return -> Bool
== :: Return -> Return -> Bool
$c/= :: Return -> Return -> Bool
/= :: Return -> Return -> Bool
Eq, Eq Return
Eq Return =>
(Return -> Return -> Ordering)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Bool)
-> (Return -> Return -> Return)
-> (Return -> Return -> Return)
-> Ord Return
Return -> Return -> Bool
Return -> Return -> Ordering
Return -> Return -> Return
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Return -> Return -> Ordering
compare :: Return -> Return -> Ordering
$c< :: Return -> Return -> Bool
< :: Return -> Return -> Bool
$c<= :: Return -> Return -> Bool
<= :: Return -> Return -> Bool
$c> :: Return -> Return -> Bool
> :: Return -> Return -> Bool
$c>= :: Return -> Return -> Bool
>= :: Return -> Return -> Bool
$cmax :: Return -> Return -> Return
max :: Return -> Return -> Return
$cmin :: Return -> Return -> Return
min :: Return -> Return -> Return
Ord)

data Load
  = MediumLevelILLoad MediumLevelILLoadRec
  | MediumLevelILLoadStruct MediumLevelILLoadStructRec
  | MediumLevelILLoadSsa MediumLevelILLoadSsaRec
  | MediumLevelILLoadStructSsa MediumLevelILLoadStructSsaRec
  deriving (Int -> Load -> ShowS
[Load] -> ShowS
Load -> String
(Int -> Load -> ShowS)
-> (Load -> String) -> ([Load] -> ShowS) -> Show Load
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Load -> ShowS
showsPrec :: Int -> Load -> ShowS
$cshow :: Load -> String
show :: Load -> String
$cshowList :: [Load] -> ShowS
showList :: [Load] -> ShowS
Show, Load -> Load -> Bool
(Load -> Load -> Bool) -> (Load -> Load -> Bool) -> Eq Load
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Load -> Load -> Bool
== :: Load -> Load -> Bool
$c/= :: Load -> Load -> Bool
/= :: Load -> Load -> Bool
Eq, Eq Load
Eq Load =>
(Load -> Load -> Ordering)
-> (Load -> Load -> Bool)
-> (Load -> Load -> Bool)
-> (Load -> Load -> Bool)
-> (Load -> Load -> Bool)
-> (Load -> Load -> Load)
-> (Load -> Load -> Load)
-> Ord Load
Load -> Load -> Bool
Load -> Load -> Ordering
Load -> Load -> Load
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Load -> Load -> Ordering
compare :: Load -> Load -> Ordering
$c< :: Load -> Load -> Bool
< :: Load -> Load -> Bool
$c<= :: Load -> Load -> Bool
<= :: Load -> Load -> Bool
$c> :: Load -> Load -> Bool
> :: Load -> Load -> Bool
$c>= :: Load -> Load -> Bool
>= :: Load -> Load -> Bool
$cmax :: Load -> Load -> Load
max :: Load -> Load -> Load
$cmin :: Load -> Load -> Load
min :: Load -> Load -> Load
Ord)

data Store
  = MediumLevelILStore MediumLevelILStoreRec
  | MediumLevelILStoreStruct MediumLevelILStoreStructRec
  | MediumLevelILStoreSsa MediumLevelILStoreSsaRec
  | MediumLevelILStoreStructSsa MediumLevelILStoreStructSsaRec
  | MediumLevelILStoreOutput MediumLevelILStoreOutputRec
  deriving (Int -> Store -> ShowS
[Store] -> ShowS
Store -> String
(Int -> Store -> ShowS)
-> (Store -> String) -> ([Store] -> ShowS) -> Show Store
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Store -> ShowS
showsPrec :: Int -> Store -> ShowS
$cshow :: Store -> String
show :: Store -> String
$cshowList :: [Store] -> ShowS
showList :: [Store] -> ShowS
Show, Store -> Store -> Bool
(Store -> Store -> Bool) -> (Store -> Store -> Bool) -> Eq Store
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Store -> Store -> Bool
== :: Store -> Store -> Bool
$c/= :: Store -> Store -> Bool
/= :: Store -> Store -> Bool
Eq, Eq Store
Eq Store =>
(Store -> Store -> Ordering)
-> (Store -> Store -> Bool)
-> (Store -> Store -> Bool)
-> (Store -> Store -> Bool)
-> (Store -> Store -> Bool)
-> (Store -> Store -> Store)
-> (Store -> Store -> Store)
-> Ord Store
Store -> Store -> Bool
Store -> Store -> Ordering
Store -> Store -> Store
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Store -> Store -> Ordering
compare :: Store -> Store -> Ordering
$c< :: Store -> Store -> Bool
< :: Store -> Store -> Bool
$c<= :: Store -> Store -> Bool
<= :: Store -> Store -> Bool
$c> :: Store -> Store -> Bool
> :: Store -> Store -> Bool
$c>= :: Store -> Store -> Bool
>= :: Store -> Store -> Bool
$cmax :: Store -> Store -> Store
max :: Store -> Store -> Store
$cmin :: Store -> Store -> Store
min :: Store -> Store -> Store
Ord)

data Memory
  = MediumLevelILUnimplMem MediumLevelILUnimplMemRec
  | MediumLevelILMemPhi MediumLevelILMemPhiRec
  deriving (Int -> Memory -> ShowS
[Memory] -> ShowS
Memory -> String
(Int -> Memory -> ShowS)
-> (Memory -> String) -> ([Memory] -> ShowS) -> Show Memory
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Memory -> ShowS
showsPrec :: Int -> Memory -> ShowS
$cshow :: Memory -> String
show :: Memory -> String
$cshowList :: [Memory] -> ShowS
showList :: [Memory] -> ShowS
Show, Memory -> Memory -> Bool
(Memory -> Memory -> Bool)
-> (Memory -> Memory -> Bool) -> Eq Memory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Memory -> Memory -> Bool
== :: Memory -> Memory -> Bool
$c/= :: Memory -> Memory -> Bool
/= :: Memory -> Memory -> Bool
Eq, Eq Memory
Eq Memory =>
(Memory -> Memory -> Ordering)
-> (Memory -> Memory -> Bool)
-> (Memory -> Memory -> Bool)
-> (Memory -> Memory -> Bool)
-> (Memory -> Memory -> Bool)
-> (Memory -> Memory -> Memory)
-> (Memory -> Memory -> Memory)
-> Ord Memory
Memory -> Memory -> Bool
Memory -> Memory -> Ordering
Memory -> Memory -> Memory
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Memory -> Memory -> Ordering
compare :: Memory -> Memory -> Ordering
$c< :: Memory -> Memory -> Bool
< :: Memory -> Memory -> Bool
$c<= :: Memory -> Memory -> Bool
<= :: Memory -> Memory -> Bool
$c> :: Memory -> Memory -> Bool
> :: Memory -> Memory -> Bool
$c>= :: Memory -> Memory -> Bool
>= :: Memory -> Memory -> Bool
$cmax :: Memory -> Memory -> Memory
max :: Memory -> Memory -> Memory
$cmin :: Memory -> Memory -> Memory
min :: Memory -> Memory -> Memory
Ord)

data Carry
  = MediumLevelILAdc MediumLevelILAdcRec
  | MediumLevelILSbb MediumLevelILSbbRec
  | MediumLevelILRlc MediumLevelILRlcRec
  | MediumLevelILRrc MediumLevelILRrcRec
  deriving (Int -> Carry -> ShowS
[Carry] -> ShowS
Carry -> String
(Int -> Carry -> ShowS)
-> (Carry -> String) -> ([Carry] -> ShowS) -> Show Carry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Carry -> ShowS
showsPrec :: Int -> Carry -> ShowS
$cshow :: Carry -> String
show :: Carry -> String
$cshowList :: [Carry] -> ShowS
showList :: [Carry] -> ShowS
Show, Carry -> Carry -> Bool
(Carry -> Carry -> Bool) -> (Carry -> Carry -> Bool) -> Eq Carry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Carry -> Carry -> Bool
== :: Carry -> Carry -> Bool
$c/= :: Carry -> Carry -> Bool
/= :: Carry -> Carry -> Bool
Eq, Eq Carry
Eq Carry =>
(Carry -> Carry -> Ordering)
-> (Carry -> Carry -> Bool)
-> (Carry -> Carry -> Bool)
-> (Carry -> Carry -> Bool)
-> (Carry -> Carry -> Bool)
-> (Carry -> Carry -> Carry)
-> (Carry -> Carry -> Carry)
-> Ord Carry
Carry -> Carry -> Bool
Carry -> Carry -> Ordering
Carry -> Carry -> Carry
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Carry -> Carry -> Ordering
compare :: Carry -> Carry -> Ordering
$c< :: Carry -> Carry -> Bool
< :: Carry -> Carry -> Bool
$c<= :: Carry -> Carry -> Bool
<= :: Carry -> Carry -> Bool
$c> :: Carry -> Carry -> Bool
> :: Carry -> Carry -> Bool
$c>= :: Carry -> Carry -> Bool
>= :: Carry -> Carry -> Bool
$cmax :: Carry -> Carry -> Carry
max :: Carry -> Carry -> Carry
$cmin :: Carry -> Carry -> Carry
min :: Carry -> Carry -> Carry
Ord)

data SetVar
  = MediumLevelILSetVar MediumLevelILSetVarRec
  | MediumLevelILVarPhi MediumLevelILVarPhiRec
  | MediumLevelILSetVarSsa MediumLevelILSetVarSsaRec
  | MediumLevelILSetVarAliased MediumLevelILSetVarAliasedRec
  | MediumLevelILSetVarSsaField MediumLevelILSetVarSsaFieldRec
  | MediumLevelILSetVarSplitSsa MediumLevelILSetVarSplitSsaRec
  | MediumLevelILSetVarAliasedField MediumLevelILSetVarAliasedFieldRec
  | MediumLevelILSetVarField MediumLevelILSetVarFieldRec
  | MediumLevelILSetVarSplit MediumLevelILSetVarSplitRec
  | MediumLevelILVarOutputField MediumLevelILVarOutputFieldRec
  | MediumLevelILVarOutputSsaField MediumLevelILVarOutputSsaFieldRec
  | MediumLevelILVarOutputAliased MediumLevelILVarOutputAliasedRec
  | MediumLevelILVarOutputAliasedField MediumLevelILVarOutputAliasedFieldRec
  deriving (Int -> SetVar -> ShowS
[SetVar] -> ShowS
SetVar -> String
(Int -> SetVar -> ShowS)
-> (SetVar -> String) -> ([SetVar] -> ShowS) -> Show SetVar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetVar -> ShowS
showsPrec :: Int -> SetVar -> ShowS
$cshow :: SetVar -> String
show :: SetVar -> String
$cshowList :: [SetVar] -> ShowS
showList :: [SetVar] -> ShowS
Show, SetVar -> SetVar -> Bool
(SetVar -> SetVar -> Bool)
-> (SetVar -> SetVar -> Bool) -> Eq SetVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetVar -> SetVar -> Bool
== :: SetVar -> SetVar -> Bool
$c/= :: SetVar -> SetVar -> Bool
/= :: SetVar -> SetVar -> Bool
Eq, Eq SetVar
Eq SetVar =>
(SetVar -> SetVar -> Ordering)
-> (SetVar -> SetVar -> Bool)
-> (SetVar -> SetVar -> Bool)
-> (SetVar -> SetVar -> Bool)
-> (SetVar -> SetVar -> Bool)
-> (SetVar -> SetVar -> SetVar)
-> (SetVar -> SetVar -> SetVar)
-> Ord SetVar
SetVar -> SetVar -> Bool
SetVar -> SetVar -> Ordering
SetVar -> SetVar -> SetVar
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SetVar -> SetVar -> Ordering
compare :: SetVar -> SetVar -> Ordering
$c< :: SetVar -> SetVar -> Bool
< :: SetVar -> SetVar -> Bool
$c<= :: SetVar -> SetVar -> Bool
<= :: SetVar -> SetVar -> Bool
$c> :: SetVar -> SetVar -> Bool
> :: SetVar -> SetVar -> Bool
$c>= :: SetVar -> SetVar -> Bool
>= :: SetVar -> SetVar -> Bool
$cmax :: SetVar -> SetVar -> SetVar
max :: SetVar -> SetVar -> SetVar
$cmin :: SetVar -> SetVar -> SetVar
min :: SetVar -> SetVar -> SetVar
Ord)

data RegisterStack
  = MediumLevelILFreeVarSlot MediumLevelILFreeVarSlotRec
  | MediumLevelILFreeVarSlotSsa MediumLevelILFreeVarSlotSsaRec
  | MediumLevelILVarOutput MediumLevelILVarOutputRec
  deriving (Int -> RegisterStack -> ShowS
[RegisterStack] -> ShowS
RegisterStack -> String
(Int -> RegisterStack -> ShowS)
-> (RegisterStack -> String)
-> ([RegisterStack] -> ShowS)
-> Show RegisterStack
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RegisterStack -> ShowS
showsPrec :: Int -> RegisterStack -> ShowS
$cshow :: RegisterStack -> String
show :: RegisterStack -> String
$cshowList :: [RegisterStack] -> ShowS
showList :: [RegisterStack] -> ShowS
Show, RegisterStack -> RegisterStack -> Bool
(RegisterStack -> RegisterStack -> Bool)
-> (RegisterStack -> RegisterStack -> Bool) -> Eq RegisterStack
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegisterStack -> RegisterStack -> Bool
== :: RegisterStack -> RegisterStack -> Bool
$c/= :: RegisterStack -> RegisterStack -> Bool
/= :: RegisterStack -> RegisterStack -> Bool
Eq, Eq RegisterStack
Eq RegisterStack =>
(RegisterStack -> RegisterStack -> Ordering)
-> (RegisterStack -> RegisterStack -> Bool)
-> (RegisterStack -> RegisterStack -> Bool)
-> (RegisterStack -> RegisterStack -> Bool)
-> (RegisterStack -> RegisterStack -> Bool)
-> (RegisterStack -> RegisterStack -> RegisterStack)
-> (RegisterStack -> RegisterStack -> RegisterStack)
-> Ord RegisterStack
RegisterStack -> RegisterStack -> Bool
RegisterStack -> RegisterStack -> Ordering
RegisterStack -> RegisterStack -> RegisterStack
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RegisterStack -> RegisterStack -> Ordering
compare :: RegisterStack -> RegisterStack -> Ordering
$c< :: RegisterStack -> RegisterStack -> Bool
< :: RegisterStack -> RegisterStack -> Bool
$c<= :: RegisterStack -> RegisterStack -> Bool
<= :: RegisterStack -> RegisterStack -> Bool
$c> :: RegisterStack -> RegisterStack -> Bool
> :: RegisterStack -> RegisterStack -> Bool
$c>= :: RegisterStack -> RegisterStack -> Bool
>= :: RegisterStack -> RegisterStack -> Bool
$cmax :: RegisterStack -> RegisterStack -> RegisterStack
max :: RegisterStack -> RegisterStack -> RegisterStack
$cmin :: RegisterStack -> RegisterStack -> RegisterStack
min :: RegisterStack -> RegisterStack -> RegisterStack
Ord)

data VariableInstruction
  = MediumLevelILVar MediumLevelILVarRec
  | MediumLevelILVarSsa MediumLevelILVarSsaRec
  | MediumLevelILVarAliased MediumLevelILVarAliasedRec
  | MediumLevelILVarSsaField MediumLevelILVarSsaFieldRec
  | MediumLevelILVarAliasedField MediumLevelILVarAliasedFieldRec
  | MediumLevelILVarSplitSsa MediumLevelILVarSplitSsaRec
  deriving (Int -> VariableInstruction -> ShowS
[VariableInstruction] -> ShowS
VariableInstruction -> String
(Int -> VariableInstruction -> ShowS)
-> (VariableInstruction -> String)
-> ([VariableInstruction] -> ShowS)
-> Show VariableInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VariableInstruction -> ShowS
showsPrec :: Int -> VariableInstruction -> ShowS
$cshow :: VariableInstruction -> String
show :: VariableInstruction -> String
$cshowList :: [VariableInstruction] -> ShowS
showList :: [VariableInstruction] -> ShowS
Show, VariableInstruction -> VariableInstruction -> Bool
(VariableInstruction -> VariableInstruction -> Bool)
-> (VariableInstruction -> VariableInstruction -> Bool)
-> Eq VariableInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableInstruction -> VariableInstruction -> Bool
== :: VariableInstruction -> VariableInstruction -> Bool
$c/= :: VariableInstruction -> VariableInstruction -> Bool
/= :: VariableInstruction -> VariableInstruction -> Bool
Eq, Eq VariableInstruction
Eq VariableInstruction =>
(VariableInstruction -> VariableInstruction -> Ordering)
-> (VariableInstruction -> VariableInstruction -> Bool)
-> (VariableInstruction -> VariableInstruction -> Bool)
-> (VariableInstruction -> VariableInstruction -> Bool)
-> (VariableInstruction -> VariableInstruction -> Bool)
-> (VariableInstruction
    -> VariableInstruction -> VariableInstruction)
-> (VariableInstruction
    -> VariableInstruction -> VariableInstruction)
-> Ord VariableInstruction
VariableInstruction -> VariableInstruction -> Bool
VariableInstruction -> VariableInstruction -> Ordering
VariableInstruction -> VariableInstruction -> VariableInstruction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableInstruction -> VariableInstruction -> Ordering
compare :: VariableInstruction -> VariableInstruction -> Ordering
$c< :: VariableInstruction -> VariableInstruction -> Bool
< :: VariableInstruction -> VariableInstruction -> Bool
$c<= :: VariableInstruction -> VariableInstruction -> Bool
<= :: VariableInstruction -> VariableInstruction -> Bool
$c> :: VariableInstruction -> VariableInstruction -> Bool
> :: VariableInstruction -> VariableInstruction -> Bool
$c>= :: VariableInstruction -> VariableInstruction -> Bool
>= :: VariableInstruction -> VariableInstruction -> Bool
$cmax :: VariableInstruction -> VariableInstruction -> VariableInstruction
max :: VariableInstruction -> VariableInstruction -> VariableInstruction
$cmin :: VariableInstruction -> VariableInstruction -> VariableInstruction
min :: VariableInstruction -> VariableInstruction -> VariableInstruction
Ord)

data IntrinsicInstruction
  = MediumLevelILIntrinsic MediumLevelILIntrinsicRec
  | MediumLevelILIntrinsicSsa MediumLevelILIntrinsicSsaRec
  | MediumLevelILMemoryIntrinsicSsa MediumLevelILMemoryIntrinsicSsaRec
  deriving (Int -> IntrinsicInstruction -> ShowS
[IntrinsicInstruction] -> ShowS
IntrinsicInstruction -> String
(Int -> IntrinsicInstruction -> ShowS)
-> (IntrinsicInstruction -> String)
-> ([IntrinsicInstruction] -> ShowS)
-> Show IntrinsicInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IntrinsicInstruction -> ShowS
showsPrec :: Int -> IntrinsicInstruction -> ShowS
$cshow :: IntrinsicInstruction -> String
show :: IntrinsicInstruction -> String
$cshowList :: [IntrinsicInstruction] -> ShowS
showList :: [IntrinsicInstruction] -> ShowS
Show, IntrinsicInstruction -> IntrinsicInstruction -> Bool
(IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> (IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> Eq IntrinsicInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
== :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
$c/= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
/= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
Eq, Eq IntrinsicInstruction
Eq IntrinsicInstruction =>
(IntrinsicInstruction -> IntrinsicInstruction -> Ordering)
-> (IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> (IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> (IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> (IntrinsicInstruction -> IntrinsicInstruction -> Bool)
-> (IntrinsicInstruction
    -> IntrinsicInstruction -> IntrinsicInstruction)
-> (IntrinsicInstruction
    -> IntrinsicInstruction -> IntrinsicInstruction)
-> Ord IntrinsicInstruction
IntrinsicInstruction -> IntrinsicInstruction -> Bool
IntrinsicInstruction -> IntrinsicInstruction -> Ordering
IntrinsicInstruction
-> IntrinsicInstruction -> IntrinsicInstruction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IntrinsicInstruction -> IntrinsicInstruction -> Ordering
compare :: IntrinsicInstruction -> IntrinsicInstruction -> Ordering
$c< :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
< :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
$c<= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
<= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
$c> :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
> :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
$c>= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
>= :: IntrinsicInstruction -> IntrinsicInstruction -> Bool
$cmax :: IntrinsicInstruction
-> IntrinsicInstruction -> IntrinsicInstruction
max :: IntrinsicInstruction
-> IntrinsicInstruction -> IntrinsicInstruction
$cmin :: IntrinsicInstruction
-> IntrinsicInstruction -> IntrinsicInstruction
min :: IntrinsicInstruction
-> IntrinsicInstruction -> IntrinsicInstruction
Ord)

data MediumLevelILSSAInstruction
  = Localcall Localcall
  | Constant Constant
  | Comparison Comparison
  | Arithmetic Arithmetic
  | Terminal Terminal
  | Syscall Syscall
  | Tailcall Tailcall
  | ControlFlow ControlFlow
  | Return Return
  | Load Load
  | Store Store
  | Memory Memory
  | Carry Carry
  | VariableInstruction VariableInstruction
  | SetVar SetVar
  | RegisterStack RegisterStack
  | IntrinsicInstruction IntrinsicInstruction
  | MediumLevelILCallOutputSsa MediumLevelILCallOutputSsaRec
  | MediumLevelILMemoryIntrinsicOutputSsa MediumLevelILMemoryIntrinsicOutputSsaRec
  | MediumLevelILCallParamSsa MediumLevelILCallParamSsaRec
  | MediumLevelILCallParam MediumLevelILCallParamRec
  | MediumLevelILNop MediumLevelILNopRec
  | MediumLevelILAddressOf MediumLevelILAddressOfRec
  | MediumLevelILAddressOfField MediumLevelILAddressOfFieldRec
  | MediumLevelILPassByRef MediumLevelILPassByRefRec
  | MediumLevelILReturnByRef MediumLevelILReturnByRefRec
  | MediumLevelILMuluDp MediumLevelILMuluDpRec
  | MediumLevelILMulsDp MediumLevelILMulsDpRec
  | MediumLevelILDivuDp MediumLevelILDivuDpRec
  | MediumLevelILDivsDp MediumLevelILDivsDpRec
  | MediumLevelILModuDp MediumLevelILModuDpRec
  | MediumLevelILModsDp MediumLevelILModsDpRec
  | MediumLevelILBoolToInt MediumLevelILBoolToIntRec
  | MediumLevelILAssert MediumLevelILAssertRec
  | MediumLevelILAssertSsa MediumLevelILAssertSsaRec
  | MediumLevelILForceVer MediumLevelILForceVerRec
  | MediumLevelILForceVerSsa MediumLevelILForceVerSsaRec
  | MediumLevelILVarField MediumLevelILVarFieldRec
  | MediumLevelILVarSplit MediumLevelILVarSplitRec
  | MediumLevelILUndef MediumLevelILUndefRec
  | MediumLevelILUnimpl MediumLevelILUnimplRec
  | MediumLevelILSeparateParamList MediumLevelILSeparateParamListRec
  | MediumLevelILSharedParamSlot MediumLevelILSharedParamSlotRec
  | MediumLevelILVarOutputSsa MediumLevelILVarOutputSsaRec
  | MediumLevelILBlockToExpand MediumLevelILBlockToExpandRec
  deriving (Int -> MediumLevelILSSAInstruction -> ShowS
[MediumLevelILSSAInstruction] -> ShowS
MediumLevelILSSAInstruction -> String
(Int -> MediumLevelILSSAInstruction -> ShowS)
-> (MediumLevelILSSAInstruction -> String)
-> ([MediumLevelILSSAInstruction] -> ShowS)
-> Show MediumLevelILSSAInstruction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MediumLevelILSSAInstruction -> ShowS
showsPrec :: Int -> MediumLevelILSSAInstruction -> ShowS
$cshow :: MediumLevelILSSAInstruction -> String
show :: MediumLevelILSSAInstruction -> String
$cshowList :: [MediumLevelILSSAInstruction] -> ShowS
showList :: [MediumLevelILSSAInstruction] -> ShowS
Show, MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
(MediumLevelILSSAInstruction
 -> MediumLevelILSSAInstruction -> Bool)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> Bool)
-> Eq MediumLevelILSSAInstruction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
== :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
$c/= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
/= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
Eq, Eq MediumLevelILSSAInstruction
Eq MediumLevelILSSAInstruction =>
(MediumLevelILSSAInstruction
 -> MediumLevelILSSAInstruction -> Ordering)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> Bool)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> Bool)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> Bool)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> Bool)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction)
-> (MediumLevelILSSAInstruction
    -> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction)
-> Ord MediumLevelILSSAInstruction
MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> Ordering
MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> Ordering
compare :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> Ordering
$c< :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
< :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
$c<= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
<= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
$c> :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
> :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
$c>= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
>= :: MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction -> Bool
$cmax :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction
max :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction
$cmin :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction
min :: MediumLevelILSSAInstruction
-> MediumLevelILSSAInstruction -> MediumLevelILSSAInstruction
Ord)

data DataVariable = DataVariable
  { DataVariable -> Word64
address :: !Word64,
    DataVariable -> BNTypeClass
ty :: !BNTypeClass,
    DataVariable -> Bool
autoDiscovered :: !Bool,
    DataVariable -> Word8
typeConfidence :: !Word8,
    DataVariable -> Word64
width :: !Word64,
    DataVariable -> CSize
alignment :: !CSize,
    DataVariable -> BNBoolWithConfidence
isSigned :: BNBoolWithConfidence,
    DataVariable -> BNBoolWithConfidence
isConst :: BNBoolWithConfidence,
    DataVariable -> BNBoolWithConfidence
isVolatile :: BNBoolWithConfidence,
    DataVariable -> Maybe ByteString
bytes :: Maybe BS.ByteString
  }
  deriving (Int -> DataVariable -> ShowS
[DataVariable] -> ShowS
DataVariable -> String
(Int -> DataVariable -> ShowS)
-> (DataVariable -> String)
-> ([DataVariable] -> ShowS)
-> Show DataVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataVariable -> ShowS
showsPrec :: Int -> DataVariable -> ShowS
$cshow :: DataVariable -> String
show :: DataVariable -> String
$cshowList :: [DataVariable] -> ShowS
showList :: [DataVariable] -> ShowS
Show)

data BNTypeClass
  = VoidTypeClass
  | BoolTypeClass
  | IntegerTypeClass
  | FloatTypeClass
  | StructureTypeClass
  | EnumerationTypeClass
  | PointerTypeClass
  | ArrayTypeClass
  | FunctionTypeClass
  | VarArgsTypeClass
  | ValueTypeClass
  | NamedTypeReferenceClass
  | WideCharTypeClass
  | FragmentTypeClass
  deriving (Int -> BNTypeClass -> ShowS
[BNTypeClass] -> ShowS
BNTypeClass -> String
(Int -> BNTypeClass -> ShowS)
-> (BNTypeClass -> String)
-> ([BNTypeClass] -> ShowS)
-> Show BNTypeClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNTypeClass -> ShowS
showsPrec :: Int -> BNTypeClass -> ShowS
$cshow :: BNTypeClass -> String
show :: BNTypeClass -> String
$cshowList :: [BNTypeClass] -> ShowS
showList :: [BNTypeClass] -> ShowS
Show, BNTypeClass -> BNTypeClass -> Bool
(BNTypeClass -> BNTypeClass -> Bool)
-> (BNTypeClass -> BNTypeClass -> Bool) -> Eq BNTypeClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNTypeClass -> BNTypeClass -> Bool
== :: BNTypeClass -> BNTypeClass -> Bool
$c/= :: BNTypeClass -> BNTypeClass -> Bool
/= :: BNTypeClass -> BNTypeClass -> Bool
Eq, Int -> BNTypeClass
BNTypeClass -> Int
BNTypeClass -> [BNTypeClass]
BNTypeClass -> BNTypeClass
BNTypeClass -> BNTypeClass -> [BNTypeClass]
BNTypeClass -> BNTypeClass -> BNTypeClass -> [BNTypeClass]
(BNTypeClass -> BNTypeClass)
-> (BNTypeClass -> BNTypeClass)
-> (Int -> BNTypeClass)
-> (BNTypeClass -> Int)
-> (BNTypeClass -> [BNTypeClass])
-> (BNTypeClass -> BNTypeClass -> [BNTypeClass])
-> (BNTypeClass -> BNTypeClass -> [BNTypeClass])
-> (BNTypeClass -> BNTypeClass -> BNTypeClass -> [BNTypeClass])
-> Enum BNTypeClass
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNTypeClass -> BNTypeClass
succ :: BNTypeClass -> BNTypeClass
$cpred :: BNTypeClass -> BNTypeClass
pred :: BNTypeClass -> BNTypeClass
$ctoEnum :: Int -> BNTypeClass
toEnum :: Int -> BNTypeClass
$cfromEnum :: BNTypeClass -> Int
fromEnum :: BNTypeClass -> Int
$cenumFrom :: BNTypeClass -> [BNTypeClass]
enumFrom :: BNTypeClass -> [BNTypeClass]
$cenumFromThen :: BNTypeClass -> BNTypeClass -> [BNTypeClass]
enumFromThen :: BNTypeClass -> BNTypeClass -> [BNTypeClass]
$cenumFromTo :: BNTypeClass -> BNTypeClass -> [BNTypeClass]
enumFromTo :: BNTypeClass -> BNTypeClass -> [BNTypeClass]
$cenumFromThenTo :: BNTypeClass -> BNTypeClass -> BNTypeClass -> [BNTypeClass]
enumFromThenTo :: BNTypeClass -> BNTypeClass -> BNTypeClass -> [BNTypeClass]
Enum)

data BNTypeWithConfidence = BNTypeWithConfidence
  { BNTypeWithConfidence -> BNTypePtr
ty :: BNTypePtr,
    BNTypeWithConfidence -> Word8
confidence :: Word8
  }
  deriving (Int -> BNTypeWithConfidence -> ShowS
[BNTypeWithConfidence] -> ShowS
BNTypeWithConfidence -> String
(Int -> BNTypeWithConfidence -> ShowS)
-> (BNTypeWithConfidence -> String)
-> ([BNTypeWithConfidence] -> ShowS)
-> Show BNTypeWithConfidence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNTypeWithConfidence -> ShowS
showsPrec :: Int -> BNTypeWithConfidence -> ShowS
$cshow :: BNTypeWithConfidence -> String
show :: BNTypeWithConfidence -> String
$cshowList :: [BNTypeWithConfidence] -> ShowS
showList :: [BNTypeWithConfidence] -> ShowS
Show)

data BNBoolWithConfidence = BNBoolWithConfidence
  { BNBoolWithConfidence -> Bool
value :: Bool,
    BNBoolWithConfidence -> Word8
confidence :: Word8
  }
  deriving (Int -> BNBoolWithConfidence -> ShowS
[BNBoolWithConfidence] -> ShowS
BNBoolWithConfidence -> String
(Int -> BNBoolWithConfidence -> ShowS)
-> (BNBoolWithConfidence -> String)
-> ([BNBoolWithConfidence] -> ShowS)
-> Show BNBoolWithConfidence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNBoolWithConfidence -> ShowS
showsPrec :: Int -> BNBoolWithConfidence -> ShowS
$cshow :: BNBoolWithConfidence -> String
show :: BNBoolWithConfidence -> String
$cshowList :: [BNBoolWithConfidence] -> ShowS
showList :: [BNBoolWithConfidence] -> ShowS
Show)

instance Storable BNTypeWithConfidence where
  sizeOf :: BNTypeWithConfidence -> Int
sizeOf BNTypeWithConfidence
_ = Int
16
  alignment :: BNTypeWithConfidence -> Int
alignment BNTypeWithConfidence
_ = Int
alignmentS
  peek :: Ptr BNTypeWithConfidence -> IO BNTypeWithConfidence
peek Ptr BNTypeWithConfidence
ptr = do
    value' <- Ptr BNTypeWithConfidence -> Int -> IO BNTypePtr
forall b. Ptr b -> Int -> IO BNTypePtr
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNTypeWithConfidence
ptr Int
0 :: IO BNTypePtr
    confidence' <- peekByteOff ptr 8
    pure
      BNTypeWithConfidence
        { ty = value',
          confidence = confidence'
        }
  poke :: Ptr BNTypeWithConfidence -> BNTypeWithConfidence -> IO ()
poke Ptr BNTypeWithConfidence
ptr (BNTypeWithConfidence BNTypePtr
ty' Word8
confidence') = do
    Ptr BNTypeWithConfidence -> Int -> BNTypePtr -> IO ()
forall b. Ptr b -> Int -> BNTypePtr -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNTypeWithConfidence
ptr Int
0 BNTypePtr
ty'
    Ptr BNTypeWithConfidence -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNTypeWithConfidence
ptr Int
8 Word8
confidence'

instance Storable BNBoolWithConfidence where
  sizeOf :: BNBoolWithConfidence -> Int
sizeOf BNBoolWithConfidence
_ = Int
2
  alignment :: BNBoolWithConfidence -> Int
alignment BNBoolWithConfidence
_ = Int
alignmentS
  peek :: Ptr BNBoolWithConfidence -> IO BNBoolWithConfidence
peek Ptr BNBoolWithConfidence
ptr = do
    value' <- CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr BNBoolWithConfidence -> Int -> IO CBool
forall b. Ptr b -> Int -> IO CBool
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr BNBoolWithConfidence
ptr Int
0 :: IO CBool)
    confidence' <- peekByteOff ptr 1
    pure
      BNBoolWithConfidence
        { value = value',
          confidence = confidence'
        }
  poke :: Ptr BNBoolWithConfidence -> BNBoolWithConfidence -> IO ()
poke Ptr BNBoolWithConfidence
ptr (BNBoolWithConfidence Bool
value' Word8
confidence') = do
    Ptr BNBoolWithConfidence -> Int -> CBool -> IO ()
forall b. Ptr b -> Int -> CBool -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBoolWithConfidence
ptr Int
0 (Bool -> CBool
forall a. Num a => Bool -> a
fromBool Bool
value' :: CBool)
    Ptr BNBoolWithConfidence -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr BNBoolWithConfidence
ptr Int
1 Word8
confidence'

instance Storable DataVariable where
  sizeOf :: DataVariable -> Int
sizeOf DataVariable
_ = Int
24
  alignment :: DataVariable -> Int
alignment DataVariable
_ = Int
alignmentS
  peek :: Ptr DataVariable -> IO DataVariable
peek Ptr DataVariable
ptr = do
    address' <- Ptr DataVariable -> Int -> IO Word64
forall b. Ptr b -> Int -> IO Word64
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DataVariable
ptr Int
0
    ty' <- peekByteOff ptr 8 :: IO BNTypePtr
    tyClass' <- toEnum <$> fromIntegral <$> c_BNGetTypeClass ty' :: IO BNTypeClass
    autoDiscovered' <- toBool <$> (peekByteOff ptr 16 :: IO CBool)
    typeConfidence' <- peekByteOff ptr 17
    width' <- c_BNGetTypeWidth ty'
    alignment' <- c_BNGetTypeAlignment ty'
    isSigned' <- alloca $ \Ptr BNBoolWithConfidence
ptr' -> do
      Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()
c_BNIsTypeSignedPtr Ptr BNBoolWithConfidence
ptr' BNTypePtr
ty'
      Ptr BNBoolWithConfidence -> IO BNBoolWithConfidence
forall a. Storable a => Ptr a -> IO a
peek Ptr BNBoolWithConfidence
ptr'
    isConst' <- alloca $ \Ptr BNBoolWithConfidence
ptr' -> do
      Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()
c_BNIsTypeConstPtr Ptr BNBoolWithConfidence
ptr' BNTypePtr
ty'
      Ptr BNBoolWithConfidence -> IO BNBoolWithConfidence
forall a. Storable a => Ptr a -> IO a
peek Ptr BNBoolWithConfidence
ptr'
    isVolatile' <- alloca $ \Ptr BNBoolWithConfidence
ptr' -> do
      Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()
c_BNIsTypeVolatilePtr Ptr BNBoolWithConfidence
ptr' BNTypePtr
ty'
      Ptr BNBoolWithConfidence -> IO BNBoolWithConfidence
forall a. Storable a => Ptr a -> IO a
peek Ptr BNBoolWithConfidence
ptr'
    pure
      DataVariable
        { address = address',
          ty = tyClass',
          autoDiscovered = autoDiscovered',
          typeConfidence = typeConfidence',
          width = width',
          alignment = alignment',
          isSigned = isSigned',
          isConst = isConst',
          isVolatile = isVolatile',
          bytes = Nothing
        }

  poke :: Ptr DataVariable -> DataVariable -> IO ()
poke Ptr DataVariable
ptr (DataVariable Word64
address' BNTypeClass
ty' Bool
autoDiscovered' Word8
typeConfidence' Word64
_ CSize
_ BNBoolWithConfidence
_ BNBoolWithConfidence
_ BNBoolWithConfidence
_ Maybe ByteString
_) = do
    Ptr DataVariable -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr DataVariable
ptr Int
0 Word64
address'
    Ptr DataVariable -> Int -> Int -> IO ()
forall b. Ptr b -> Int -> Int -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr DataVariable
ptr Int
8 (BNTypeClass -> Int
forall a. Enum a => a -> Int
fromEnum BNTypeClass
ty')
    Ptr DataVariable -> Int -> CBool -> IO ()
forall b. Ptr b -> Int -> CBool -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr DataVariable
ptr Int
16 (Bool -> CBool
forall a. Num a => Bool -> a
fromBool Bool
autoDiscovered' :: CBool)
    Ptr DataVariable -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr DataVariable
ptr Int
17 Word8
typeConfidence'

foreign import ccall "BNGetTypeClass"
  c_BNGetTypeClass :: BNTypePtr -> IO Word8

foreign import ccall "BNGetTypeWidth"
  c_BNGetTypeWidth :: BNTypePtr -> IO Word64

foreign import ccall "BNGetTypeAlignment"
  c_BNGetTypeAlignment :: BNTypePtr -> IO CSize

foreign import ccall "BNIsTypeSignedPtr"
  c_BNIsTypeSignedPtr :: Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()

foreign import ccall "BNIsTypeConstPtr"
  c_BNIsTypeConstPtr :: Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()

foreign import ccall "BNIsTypeVolatilePtr"
  c_BNIsTypeVolatilePtr :: Ptr BNBoolWithConfidence -> BNTypePtr -> IO ()

foreign import ccall "BNGetChildTypePtr"
  c_BNGetChildTypePtr :: Ptr BNTypeWithConfidence -> BNTypePtr -> IO ()

data Segment = Segment
  { Segment -> BNSegmentPtr
handle :: BNSegmentPtr,
    Segment -> Word64
start :: Word64,
    Segment -> Word64
end :: Word64,
    Segment -> Bool
executable :: Bool,
    Segment -> Bool
writable :: Bool,
    Segment -> Bool
readable :: Bool
  }
  deriving (Int -> Segment -> ShowS
[Segment] -> ShowS
Segment -> String
(Int -> Segment -> ShowS)
-> (Segment -> String) -> ([Segment] -> ShowS) -> Show Segment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Segment -> ShowS
showsPrec :: Int -> Segment -> ShowS
$cshow :: Segment -> String
show :: Segment -> String
$cshowList :: [Segment] -> ShowS
showList :: [Segment] -> ShowS
Show)

data BNSectionSemantics
  = DefaultSectionSemantics
  | ReadOnlyCodeSectionSemantics
  | ReadOnlyDataSectionSemantics
  | ReadWriteDataSectionSemantics
  | ExternalSectionSemantics
  deriving (Int -> BNSectionSemantics -> ShowS
[BNSectionSemantics] -> ShowS
BNSectionSemantics -> String
(Int -> BNSectionSemantics -> ShowS)
-> (BNSectionSemantics -> String)
-> ([BNSectionSemantics] -> ShowS)
-> Show BNSectionSemantics
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BNSectionSemantics -> ShowS
showsPrec :: Int -> BNSectionSemantics -> ShowS
$cshow :: BNSectionSemantics -> String
show :: BNSectionSemantics -> String
$cshowList :: [BNSectionSemantics] -> ShowS
showList :: [BNSectionSemantics] -> ShowS
Show, BNSectionSemantics -> BNSectionSemantics -> Bool
(BNSectionSemantics -> BNSectionSemantics -> Bool)
-> (BNSectionSemantics -> BNSectionSemantics -> Bool)
-> Eq BNSectionSemantics
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BNSectionSemantics -> BNSectionSemantics -> Bool
== :: BNSectionSemantics -> BNSectionSemantics -> Bool
$c/= :: BNSectionSemantics -> BNSectionSemantics -> Bool
/= :: BNSectionSemantics -> BNSectionSemantics -> Bool
Eq, Int -> BNSectionSemantics
BNSectionSemantics -> Int
BNSectionSemantics -> [BNSectionSemantics]
BNSectionSemantics -> BNSectionSemantics
BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
BNSectionSemantics
-> BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
(BNSectionSemantics -> BNSectionSemantics)
-> (BNSectionSemantics -> BNSectionSemantics)
-> (Int -> BNSectionSemantics)
-> (BNSectionSemantics -> Int)
-> (BNSectionSemantics -> [BNSectionSemantics])
-> (BNSectionSemantics
    -> BNSectionSemantics -> [BNSectionSemantics])
-> (BNSectionSemantics
    -> BNSectionSemantics -> [BNSectionSemantics])
-> (BNSectionSemantics
    -> BNSectionSemantics
    -> BNSectionSemantics
    -> [BNSectionSemantics])
-> Enum BNSectionSemantics
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BNSectionSemantics -> BNSectionSemantics
succ :: BNSectionSemantics -> BNSectionSemantics
$cpred :: BNSectionSemantics -> BNSectionSemantics
pred :: BNSectionSemantics -> BNSectionSemantics
$ctoEnum :: Int -> BNSectionSemantics
toEnum :: Int -> BNSectionSemantics
$cfromEnum :: BNSectionSemantics -> Int
fromEnum :: BNSectionSemantics -> Int
$cenumFrom :: BNSectionSemantics -> [BNSectionSemantics]
enumFrom :: BNSectionSemantics -> [BNSectionSemantics]
$cenumFromThen :: BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
enumFromThen :: BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
$cenumFromTo :: BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
enumFromTo :: BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
$cenumFromThenTo :: BNSectionSemantics
-> BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
enumFromThenTo :: BNSectionSemantics
-> BNSectionSemantics -> BNSectionSemantics -> [BNSectionSemantics]
Enum)

data Section = Section
  { Section -> BNSectionPtr
handle :: BNSectionPtr,
    Section -> String
name :: String,
    Section -> Word64
start :: Word64,
    Section -> Word64
end :: Word64,
    Section -> BNSectionSemantics
semantics :: BNSectionSemantics,
    Section -> Word64
align :: Word64
  }

instance Show Section where
  show :: Section -> String
show (Section BNSectionPtr
_ String
name' Word64
start' Word64
end' BNSectionSemantics
semantics' Word64
align') =
    String
"Section {name = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
name'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", start address = 0x"
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word64 -> ShowS
forall a. Integral a => a -> ShowS
showHex Word64
start' String
""
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", end address = 0x"
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word64 -> ShowS
forall a. Integral a => a -> ShowS
showHex Word64
end' String
""
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", semantics = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ BNSectionSemantics -> String
forall a. Show a => a -> String
show BNSectionSemantics
semantics'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", alignment = "
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word64 -> String
forall a. Show a => a -> String
show Word64
align'
      String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"}"