{-# LINE 1 "src/Clingo/Raw/Types.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LINE 2 "src/Clingo/Raw/Types.hsc" #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Clingo.Raw.Types
(
    CBool,

    -- * Basic types
    Literal,
    Atom,
    Identifier,
    Weight,
    Logger,
    mkCallbackLogger,
    Location (..),

    -- * Symbols
    Signature,
    Symbol,
    SymbolicLiteral (..),

    -- * Model and Solving
    Model (..),
    SolveHandle(..),
    SolveControl (..),

    -- * Symbolic and Theory Atoms
    SymbolicAtoms (..),
    SymbolicAtomIterator,
    TheoryAtoms (..),

    -- * Propagators
    PropagateInit (..),
    Assignment (..),
    PropagateControl (..),
    CallbackPropagatorInit,
    mkCallbackPropagatorInit,
    CallbackPropagatorPropagate,
    mkCallbackPropagatorPropagate,
    CallbackPropagatorUndo,
    mkCallbackPropagatorUndo,
    CallbackPropagatorCheck,
    mkCallbackPropagatorCheck,
    Propagator (..),

    -- * Program Builder
    WeightedLiteral (..),
    Backend (..),
    ProgramBuilder (..),

    -- * Configuration & Statistics
    Configuration (..),
    Statistics (..),

    -- * Program Inspection
    GroundProgramObserver (..),
    mkGpoInitProgram,
    mkGpoBeginStep,
    mkGpoEndStep,
    mkGpoRule,
    mkGpoWeightRule,
    mkGpoMinimize,
    mkGpoProject,
    mkGpoExternal,
    mkGpoAssume,
    mkGpoHeuristic,
    mkGpoAcycEdge,
    mkGpoTheoryTermNum,
    mkGpoTheoryTermStr,
    mkGpoTheoryTermCmp,
    mkGpoTheoryElement,
    mkGpoTheoryAtom,
    mkGpoTheoryAtomGrd,

    -- * Control
    Control (..),
    Part (..),
    CallbackSymbol,
    mkCallbackSymbol,
    getCallbackSymbol,
    CallbackGround,
    mkCallbackGround,
    CallbackEvent,
    mkCallbackEvent,
    CallbackFinish,
    mkCallbackFinish
)
where

import Data.Int
import Data.Word
import Foreign
import Foreign.C

import Clingo.Raw.Enums


{-# LINE 97 "src/Clingo/Raw/Types.hsc" #-}

type CBool = Word8
{-# LINE 99 "src/Clingo/Raw/Types.hsc" #-}

type Literal = Int32
{-# LINE 101 "src/Clingo/Raw/Types.hsc" #-}
type Atom = Word32
{-# LINE 102 "src/Clingo/Raw/Types.hsc" #-}
type Identifier = Word32
{-# LINE 103 "src/Clingo/Raw/Types.hsc" #-}
type Weight = Int32
{-# LINE 104 "src/Clingo/Raw/Types.hsc" #-}

type Logger a = ClingoWarning -> Ptr CChar -> Ptr a -> IO ()

foreign import ccall "wrapper" mkCallbackLogger ::
    Logger a -> IO (FunPtr (Logger a))

data Location = Location
    { locBeginFile :: CString
    , locEndFile   :: CString
    , locBeginLine :: Word64
{-# LINE 114 "src/Clingo/Raw/Types.hsc" #-}
    , locEndLine   :: Word64
{-# LINE 115 "src/Clingo/Raw/Types.hsc" #-}
    , locBeginCol  :: Word64
{-# LINE 116 "src/Clingo/Raw/Types.hsc" #-}
    , locEndCol    :: Word64}
{-# LINE 117 "src/Clingo/Raw/Types.hsc" #-}
    deriving (Eq, Show)

instance Storable Location where
    sizeOf _ = (48)
{-# LINE 121 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf

    peek p = Location 
        <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 125 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 126 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 127 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 128 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 32) p)
{-# LINE 129 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
{-# LINE 130 "src/Clingo/Raw/Types.hsc" #-}

    poke p l = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (locBeginFile l)
{-# LINE 133 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (locEndFile l)
{-# LINE 134 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (locBeginLine l)
{-# LINE 135 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (locEndLine l)
{-# LINE 136 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 32)) p (locBeginCol l)
{-# LINE 137 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 40)) p (locEndCol l)
{-# LINE 138 "src/Clingo/Raw/Types.hsc" #-}

type Signature = Word64
{-# LINE 140 "src/Clingo/Raw/Types.hsc" #-}
type Symbol = Word64
{-# LINE 141 "src/Clingo/Raw/Types.hsc" #-}

data SymbolicLiteral = SymbolicLiteral
    { slitSymbol   :: Symbol
    , slitPositive :: CBool }

instance Storable SymbolicLiteral where
    sizeOf _ = (16)
{-# LINE 148 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf
    peek p = SymbolicLiteral
         <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 151 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 152 "src/Clingo/Raw/Types.hsc" #-}

    poke p lit = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (slitSymbol lit)
{-# LINE 155 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (slitPositive lit)
{-# LINE 156 "src/Clingo/Raw/Types.hsc" #-}

newtype SolveHandle = SolveHandle (Ptr SolveHandle) deriving Storable
newtype SolveControl = SolveControl (Ptr SolveControl) deriving Storable
newtype Model = Model (Ptr Model) deriving Storable
newtype SymbolicAtoms = SymbolicAtoms (Ptr SymbolicAtoms) deriving Storable

type SymbolicAtomIterator = Word64
{-# LINE 163 "src/Clingo/Raw/Types.hsc" #-}

newtype TheoryAtoms = TheoryAtoms (Ptr TheoryAtoms) deriving Storable
newtype PropagateInit = PropagateInit (Ptr PropagateInit) deriving Storable
newtype Assignment = Assignment (Ptr Assignment) deriving Storable
newtype PropagateControl = PropagateControl (Ptr PropagateControl) 
    deriving Storable

type CallbackPropagatorInit a = 
    PropagateInit -> Ptr a -> IO (CBool)

foreign import ccall "wrapper" mkCallbackPropagatorInit ::
    CallbackPropagatorInit a -> IO (FunPtr (CallbackPropagatorInit a))

type CallbackPropagatorPropagate a = 
    PropagateControl -> Ptr Literal -> CSize -> Ptr a -> IO CBool

foreign import ccall "wrapper" mkCallbackPropagatorPropagate ::
    CallbackPropagatorPropagate a -> IO (FunPtr (CallbackPropagatorPropagate a))

type CallbackPropagatorUndo a = 
    PropagateControl -> Ptr Literal -> CSize -> Ptr a -> IO CBool

foreign import ccall "wrapper" mkCallbackPropagatorUndo ::
    CallbackPropagatorUndo a -> IO (FunPtr (CallbackPropagatorUndo a))

type CallbackPropagatorCheck a = 
    PropagateControl -> Ptr a -> IO CBool

foreign import ccall "wrapper" mkCallbackPropagatorCheck ::
    CallbackPropagatorCheck a -> IO (FunPtr (CallbackPropagatorCheck a))

data Propagator a = Propagator
    { propagatorInit      :: FunPtr (CallbackPropagatorInit a)
    , propagatorPropagate :: FunPtr (CallbackPropagatorPropagate a)
    , propagatorUndo      :: FunPtr (CallbackPropagatorUndo a)
    , propagatorCheck     :: FunPtr (CallbackPropagatorCheck a)
    }

instance Storable (Propagator a) where
    sizeOf _ = (32)
{-# LINE 203 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf
    peek p = Propagator 
         <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 206 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 207 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 208 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 209 "src/Clingo/Raw/Types.hsc" #-}

    poke p prop = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (propagatorInit prop)
{-# LINE 212 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (propagatorPropagate prop)
{-# LINE 213 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (propagatorUndo prop)
{-# LINE 214 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (propagatorCheck prop)
{-# LINE 215 "src/Clingo/Raw/Types.hsc" #-}

data WeightedLiteral = WeightedLiteral
    { wlLiteral :: Literal
    , wlWeight  :: Weight
    }

instance Storable WeightedLiteral where
    sizeOf _ = (8)
{-# LINE 223 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf
    peek p = WeightedLiteral
         <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 226 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 4) p)
{-# LINE 227 "src/Clingo/Raw/Types.hsc" #-}

    poke p wl = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (wlLiteral wl)
{-# LINE 230 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) p (wlWeight wl)
{-# LINE 231 "src/Clingo/Raw/Types.hsc" #-}

newtype Backend = Backend (Ptr Backend) deriving Storable
newtype Configuration = Configuration (Ptr Configuration) deriving Storable
newtype Statistics = Statistics (Ptr Statistics) deriving Storable
newtype ProgramBuilder = ProgramBuilder (Ptr ProgramBuilder) deriving Storable

data GroundProgramObserver a = GroundProgramObserver
    { gpoInitProgram   :: FunPtr (CBool -> Ptr a -> IO CBool)
    , gpoBeginStep     :: FunPtr (Ptr a -> IO CBool)
    , gpoEndStep       :: FunPtr (Ptr a -> IO CBool)
    , gpoRule          :: FunPtr (CBool -> Ptr Atom -> CSize 
                                               -> Ptr Literal -> CSize 
                                               -> Ptr a -> IO CBool)
    , gpoWeightRule    :: FunPtr (CBool -> Ptr Atom -> CSize -> Weight 
                                               -> Ptr WeightedLiteral -> CSize 
                                               -> Ptr a -> IO CBool)
    , gpoMinimize      :: FunPtr (Weight -> Ptr WeightedLiteral -> CSize 
                                         -> Ptr a -> IO CBool)
    , gpoProject       :: FunPtr (Ptr Atom -> CSize -> Ptr a -> IO CBool)
    , gpoExternal      :: FunPtr (Atom -> ExternalType -> Ptr a -> IO CBool)
    , gpoAssume        :: FunPtr (Ptr Literal -> CSize -> Ptr a -> IO CBool)
    , gpoHeuristic     :: FunPtr (Atom -> HeuristicType -> CInt 
                                       -> CUInt -> Ptr Literal -> CSize 
                                       -> Ptr a -> IO CBool)
    , gpoAcycEdge      :: FunPtr (CInt -> CInt -> Ptr Literal -> CSize 
                                       -> Ptr a -> IO CBool)
    , gpoTheoryTermNum :: FunPtr (Identifier -> CInt -> Ptr a -> IO CBool)
    , gpoTheoryTermStr :: FunPtr (Identifier -> Ptr CChar -> Ptr a -> IO CBool)
    , gpoTheoryTermCmp :: FunPtr (Identifier -> CInt -> Ptr Identifier -> CSize 
                                             -> Ptr a -> IO CBool)
    , gpoTheoryElement :: FunPtr (Identifier -> Ptr Identifier -> CSize 
                                             -> Ptr Literal -> CSize -> Ptr a 
                                             -> IO CBool)
    , gpoTheoryAtom    :: FunPtr (Identifier -> Identifier -> Ptr Identifier 
                                             -> CSize -> IO CBool)
    , gpoTheoryAtomGrd :: FunPtr (Identifier -> Identifier -> Ptr Identifier 
                                             -> CSize -> Identifier 
                                             -> Identifier -> Ptr a 
                                             -> IO CBool)
    }

foreign import ccall "wrapper" mkGpoInitProgram :: 
    (CBool -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoBeginStep :: 
    (Ptr a -> IO CBool) -> IO (FunPtr (Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoEndStep ::
    (Ptr a -> IO CBool) -> IO (FunPtr (Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoRule ::
    (CBool -> Ptr Atom -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr Atom -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoWeightRule ::
    (CBool -> Ptr Atom -> CSize -> Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CBool -> Ptr Atom -> CSize -> Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoMinimize ::
    (Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Weight -> Ptr WeightedLiteral -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoProject ::
    (Ptr Atom -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Ptr Atom -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoExternal ::
    (Atom -> ExternalType -> Ptr a -> IO CBool) -> IO (FunPtr (Atom -> ExternalType -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoAssume ::
    (Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoHeuristic ::
    (Atom -> HeuristicType -> CInt -> CUInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Atom -> HeuristicType -> CInt -> CUInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoAcycEdge ::
    (CInt -> CInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (CInt -> CInt -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermNum ::
    (Identifier -> CInt -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> CInt -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermStr ::
    (Identifier -> Ptr CChar -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Ptr CChar -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryTermCmp ::
    (Identifier -> CInt -> Ptr Identifier -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> CInt -> Ptr Identifier -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryElement ::
    (Identifier -> Ptr Identifier -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Ptr Identifier -> CSize -> Ptr Literal -> CSize -> Ptr a -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryAtom ::
    (Identifier -> Identifier -> Ptr Identifier -> CSize -> IO CBool) -> IO (FunPtr (Identifier -> Identifier -> Ptr Identifier -> CSize -> IO CBool))
foreign import ccall "wrapper" mkGpoTheoryAtomGrd ::
    (Identifier -> Identifier -> Ptr Identifier -> CSize -> Identifier -> Identifier -> Ptr a -> IO CBool) -> IO (FunPtr (Identifier -> Identifier -> Ptr Identifier -> CSize -> Identifier -> Identifier -> Ptr a -> IO CBool))

instance Storable (GroundProgramObserver a) where
    sizeOf _ = (160)
{-# LINE 309 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf
    peek p = GroundProgramObserver
        <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 312 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 313 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 314 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 24) p)
{-# LINE 315 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 32) p)
{-# LINE 316 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 40) p)
{-# LINE 317 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 48) p)
{-# LINE 318 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 80) p)
{-# LINE 319 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 88) p)
{-# LINE 320 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 96) p)
{-# LINE 321 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 104) p)
{-# LINE 322 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 112) p)
{-# LINE 323 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 120) p)
{-# LINE 324 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 128) p)
{-# LINE 325 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 136) p)
{-# LINE 326 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 144) p)
{-# LINE 327 "src/Clingo/Raw/Types.hsc" #-}
        <*> ((\hsc_ptr -> peekByteOff hsc_ptr 152) p)
{-# LINE 328 "src/Clingo/Raw/Types.hsc" #-}

    poke p g = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p 
{-# LINE 331 "src/Clingo/Raw/Types.hsc" #-}
            (gpoInitProgram g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (gpoBeginStep g)
{-# LINE 333 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (gpoEndStep g)
{-# LINE 334 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24)) p (gpoRule g)
{-# LINE 335 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 32)) p 
{-# LINE 336 "src/Clingo/Raw/Types.hsc" #-}
            (gpoWeightRule g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 40)) p (gpoMinimize g)
{-# LINE 338 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 48)) p (gpoProject g)
{-# LINE 339 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 80)) p (gpoExternal g)
{-# LINE 340 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 88)) p (gpoAssume g)
{-# LINE 341 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 96)) p (gpoHeuristic g)
{-# LINE 342 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 104)) p (gpoAcycEdge g)
{-# LINE 343 "src/Clingo/Raw/Types.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 112)) p 
{-# LINE 344 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryTermNum g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 120)) p 
{-# LINE 346 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryTermStr g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 128)) p 
{-# LINE 348 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryTermCmp g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 136)) p 
{-# LINE 350 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryElement g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 144)) p 
{-# LINE 352 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryAtom g)
        ((\hsc_ptr -> pokeByteOff hsc_ptr 152)) p 
{-# LINE 354 "src/Clingo/Raw/Types.hsc" #-}
            (gpoTheoryAtomGrd g)

newtype Control = Control (Ptr Control) deriving Storable

data Part = Part
    { partName   :: CString
    , partParams :: Ptr Symbol
    , partSize   :: CSize
    }

instance Storable Part where
    sizeOf _ = (24)
{-# LINE 366 "src/Clingo/Raw/Types.hsc" #-}
    alignment = sizeOf
    peek p = Part
         <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) p)
{-# LINE 369 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 8) p)
{-# LINE 370 "src/Clingo/Raw/Types.hsc" #-}
         <*> ((\hsc_ptr -> peekByteOff hsc_ptr 16) p)
{-# LINE 371 "src/Clingo/Raw/Types.hsc" #-}

    poke p part = do
         ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p (partName part)
{-# LINE 374 "src/Clingo/Raw/Types.hsc" #-}
         ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p (partParams part)
{-# LINE 375 "src/Clingo/Raw/Types.hsc" #-}
         ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) p (partSize part)
{-# LINE 376 "src/Clingo/Raw/Types.hsc" #-}

type CallbackSymbol a = Ptr Symbol -> CSize -> Ptr a -> IO CBool
type CallbackGround a = 
    Ptr Location -> Ptr CChar -> Ptr Symbol -> CSize -> Ptr a 
                 -> FunPtr (CallbackSymbol a) -> Ptr a -> IO CBool
type CallbackEvent a = SolveEvent -> Ptr Model -> Ptr a -> Ptr CBool -> IO CBool
type CallbackFinish a = SolveResult -> Ptr a -> IO CBool

foreign import ccall "wrapper" mkCallbackGround ::
    CallbackGround a -> IO (FunPtr (CallbackGround a))

foreign import ccall "wrapper" mkCallbackSymbol ::
    CallbackSymbol a -> IO (FunPtr (CallbackSymbol a))

foreign import ccall "dynamic" getCallbackSymbol ::
    FunPtr (CallbackSymbol a) -> CallbackSymbol a

foreign import ccall "wrapper" mkCallbackFinish ::
    CallbackFinish a -> IO (FunPtr (CallbackFinish a))

foreign import ccall "wrapper" mkCallbackEvent ::
    CallbackEvent a -> IO (FunPtr (CallbackEvent a))