module Data.LLVM.BitCode.IR.Blocks where

import Data.LLVM.BitCode.Bitstream
import Data.LLVM.BitCode.Match
import Data.LLVM.BitCode.Record

import Control.Monad ((<=<))


-- Generic Block Ids -----------------------------------------------------------

-- | Block info block selector.
blockInfoBlockId :: Match Entry [Entry]
blockInfoBlockId :: Match Entry [Entry]
blockInfoBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
0 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block


-- Module Block Ids ------------------------------------------------------------

-- | Block selector for the top-level module block.
moduleBlockId :: Match Entry [Entry]
moduleBlockId :: Match Entry [Entry]
moduleBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
8 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

paramattrBlockId :: Match Entry [Entry]
paramattrBlockId :: Match Entry [Entry]
paramattrBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
9 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

paramattrGroupBlockId :: Match Entry [Entry]
paramattrGroupBlockId :: Match Entry [Entry]
paramattrGroupBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
10 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- | Constants block selector.
constantsBlockId :: Match Entry [Entry]
constantsBlockId :: Match Entry [Entry]
constantsBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
11 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- | Function block selector.  This will succeed for function body, only.
functionBlockId :: Match Entry [Entry]
functionBlockId :: Match Entry [Entry]
functionBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
12 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- UNUSED_ID2 (13)

-- | Value symbol table block selector.
valueSymtabBlockId :: Match Entry [Entry]
valueSymtabBlockId :: Match Entry [Entry]
valueSymtabBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
14 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- | Metadata block selector.
metadataBlockId :: Match Entry [Entry]
metadataBlockId :: Match Entry [Entry]
metadataBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
15 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- | Metadata attachment block selector.
metadataAttachmentBlockId :: Match Entry [Entry]
metadataAttachmentBlockId :: Match Entry [Entry]
metadataAttachmentBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
16 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- | TYPE_BLOCK_ID_NEW
typeBlockIdNew :: Match Entry [Entry]
typeBlockIdNew :: Match Entry [Entry]
typeBlockIdNew  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
17 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

uselistBlockId :: Match Entry [Entry]
uselistBlockId :: Match Entry [Entry]
uselistBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
18 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

moduleStrtabBlockId :: Match Entry [Entry]
moduleStrtabBlockId :: Match Entry [Entry]
moduleStrtabBlockId = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
19 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

globalvalSummaryBlockId :: Match Entry [Entry]
globalvalSummaryBlockId :: Match Entry [Entry]
globalvalSummaryBlockId = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
20 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

operandBundleTagsBlockId :: Match Entry [Entry]
operandBundleTagsBlockId :: Match Entry [Entry]
operandBundleTagsBlockId = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
21 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

metadataKindBlockId :: Match Entry [Entry]
metadataKindBlockId :: Match Entry [Entry]
metadataKindBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
22 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

strtabBlockId :: Match Entry [Entry]
strtabBlockId :: Match Entry [Entry]
strtabBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
23 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

ltoSummaryBlockId :: Match Entry [Entry]
ltoSummaryBlockId :: Match Entry [Entry]
ltoSummaryBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
24 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

symtabBlockId :: Match Entry [Entry]
symtabBlockId :: Match Entry [Entry]
symtabBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
25 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

syncScopeNamesBlockId :: Match Entry [Entry]
syncScopeNamesBlockId :: Match Entry [Entry]
syncScopeNamesBlockId  = (Block -> [Entry]) -> Maybe Block -> Maybe [Entry]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> [Entry]
blockEntries (Maybe Block -> Maybe [Entry])
-> (Block -> Maybe Block) -> Block -> Maybe [Entry]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockId -> Block -> Maybe Block
hasBlockId BlockId
26 (Block -> Maybe [Entry])
-> (Entry -> Maybe Block) -> Match Entry [Entry]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Entry -> Maybe Block
block

-- Module Codes ----------------------------------------------------------------

-- | MODULE_CODE_VERSION
moduleCodeVersion :: Match Entry Record
moduleCodeVersion :: Match Entry Record
moduleCodeVersion  = Int -> Match Record Record
hasRecordCode Int
1 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

-- | MODULE_CODE_TRIPLE
moduleCodeTriple :: Match Entry Record
moduleCodeTriple :: Match Entry Record
moduleCodeTriple  = Int -> Match Record Record
hasRecordCode Int
2 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

-- | MODULE_CODE_DATALAYOUT
moduleCodeDatalayout :: Match Entry Record
moduleCodeDatalayout :: Match Entry Record
moduleCodeDatalayout  = Int -> Match Record Record
hasRecordCode Int
3 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

-- | MODULE_CODE_ASM
moduleCodeAsm :: Match Entry Record
moduleCodeAsm :: Match Entry Record
moduleCodeAsm  = Int -> Match Record Record
hasRecordCode Int
4 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeSectionname :: Match Entry Record
moduleCodeSectionname :: Match Entry Record
moduleCodeSectionname  = Int -> Match Record Record
hasRecordCode Int
5 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeDeplib :: Match Entry Record
moduleCodeDeplib :: Match Entry Record
moduleCodeDeplib  = Int -> Match Record Record
hasRecordCode Int
6 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

-- | MODULE_CODE_GLOBALVAR
moduleCodeGlobalvar :: Match Entry Record
moduleCodeGlobalvar :: Match Entry Record
moduleCodeGlobalvar  = Int -> Match Record Record
hasRecordCode Int
7 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeFunction :: Match Entry Record
moduleCodeFunction :: Match Entry Record
moduleCodeFunction  = Int -> Match Record Record
hasRecordCode Int
8 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

-- | MODULE_CODE_ALIAS
moduleCodeAlias :: Match Entry Record
moduleCodeAlias :: Match Entry Record
moduleCodeAlias  = Int -> Match Record Record
hasRecordCode Int
9 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodePurgevals :: Match Entry Record
moduleCodePurgevals :: Match Entry Record
moduleCodePurgevals  = Int -> Match Record Record
hasRecordCode Int
10 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeGcname :: Match Entry Record
moduleCodeGcname :: Match Entry Record
moduleCodeGcname  = Int -> Match Record Record
hasRecordCode Int
11 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeComdat :: Match Entry Record
moduleCodeComdat :: Match Entry Record
moduleCodeComdat = Int -> Match Record Record
hasRecordCode Int
12 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeVSTOffset :: Match Entry Record
moduleCodeVSTOffset :: Match Entry Record
moduleCodeVSTOffset = Int -> Match Record Record
hasRecordCode Int
13 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeAliasNew :: Match Entry Record
moduleCodeAliasNew :: Match Entry Record
moduleCodeAliasNew = Int -> Match Record Record
hasRecordCode Int
14 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeMDValsUnused :: Match Entry Record
moduleCodeMDValsUnused :: Match Entry Record
moduleCodeMDValsUnused = Int -> Match Record Record
hasRecordCode Int
15 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeSourceFilename :: Match Entry Record
moduleCodeSourceFilename :: Match Entry Record
moduleCodeSourceFilename = Int -> Match Record Record
hasRecordCode Int
16 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeHash :: Match Entry Record
moduleCodeHash :: Match Entry Record
moduleCodeHash = Int -> Match Record Record
hasRecordCode Int
17 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

moduleCodeIFunc :: Match Entry Record
moduleCodeIFunc :: Match Entry Record
moduleCodeIFunc = Int -> Match Record Record
hasRecordCode Int
18 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

strtabBlobId :: Match Entry Record
strtabBlobId :: Match Entry Record
strtabBlobId = Int -> Match Record Record
hasRecordCode Int
1 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry

symtabBlobId :: Match Entry Record
symtabBlobId :: Match Entry Record
symtabBlobId = Int -> Match Record Record
hasRecordCode Int
1 Match Record Record -> Match Entry Record -> Match Entry Record
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Match Entry Record
fromEntry