{-# LINE 1 "Bindings/Libgit2/Diff.hsc" #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# LINE 2 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 3 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 4 "Bindings/Libgit2/Diff.hsc" #-}
module Bindings.Libgit2.Diff where
import Foreign.Ptr
import Foreign.Ptr (Ptr,FunPtr,plusPtr)
import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Array (peekArray,pokeArray)
import Data.Int
import Data.Word

{-# LINE 7 "Bindings/Libgit2/Diff.hsc" #-}

import Bindings.Libgit2.Common
import Bindings.Libgit2.Types
import Bindings.Libgit2.Strarray
import Bindings.Libgit2.Oid
import Bindings.Libgit2.Tree
import Bindings.Libgit2.Refs
{- typedef enum {
            GIT_DIFF_NORMAL = 0,
            GIT_DIFF_REVERSE = 1 << 0,
            GIT_DIFF_FORCE_TEXT = 1 << 1,
            GIT_DIFF_IGNORE_WHITESPACE = 1 << 2,
            GIT_DIFF_IGNORE_WHITESPACE_CHANGE = 1 << 3,
            GIT_DIFF_IGNORE_WHITESPACE_EOL = 1 << 4,
            GIT_DIFF_IGNORE_SUBMODULES = 1 << 5,
            GIT_DIFF_PATIENCE = 1 << 6,
            GIT_DIFF_INCLUDE_IGNORED = 1 << 7,
            GIT_DIFF_INCLUDE_UNTRACKED = 1 << 8,
            GIT_DIFF_INCLUDE_UNMODIFIED = 1 << 9,
            GIT_DIFF_RECURSE_UNTRACKED_DIRS = 1 << 10,
            GIT_DIFF_DISABLE_PATHSPEC_MATCH = 1 << 11,
            GIT_DIFF_DELTAS_ARE_ICASE = 1 << 12,
            GIT_DIFF_INCLUDE_UNTRACKED_CONTENT = 1 << 13,
            GIT_DIFF_SKIP_BINARY_CHECK = 1 << 14,
            GIT_DIFF_INCLUDE_TYPECHANGE = 1 << 15,
            GIT_DIFF_INCLUDE_TYPECHANGE_TREES = 1 << 16,
            GIT_DIFF_IGNORE_FILEMODE = 1 << 17,
            GIT_DIFF_RECURSE_IGNORED_DIRS = 1 << 18
        } git_diff_option_t; -}
type C'git_diff_option_t = CUInt

{-# LINE 37 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_NORMAL = 0
c'GIT_DIFF_NORMAL :: (Num a) => a

{-# LINE 38 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_REVERSE = 1
c'GIT_DIFF_REVERSE :: (Num a) => a

{-# LINE 39 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FORCE_TEXT = 2
c'GIT_DIFF_FORCE_TEXT :: (Num a) => a

{-# LINE 40 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE = 4
c'GIT_DIFF_IGNORE_WHITESPACE :: (Num a) => a

{-# LINE 41 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE_CHANGE = 8
c'GIT_DIFF_IGNORE_WHITESPACE_CHANGE :: (Num a) => a

{-# LINE 42 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_WHITESPACE_EOL = 16
c'GIT_DIFF_IGNORE_WHITESPACE_EOL :: (Num a) => a

{-# LINE 43 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_SUBMODULES = 32
c'GIT_DIFF_IGNORE_SUBMODULES :: (Num a) => a

{-# LINE 44 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_PATIENCE = 64
c'GIT_DIFF_PATIENCE :: (Num a) => a

{-# LINE 45 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_IGNORED = 128
c'GIT_DIFF_INCLUDE_IGNORED :: (Num a) => a

{-# LINE 46 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_UNTRACKED = 256
c'GIT_DIFF_INCLUDE_UNTRACKED :: (Num a) => a

{-# LINE 47 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_UNMODIFIED = 512
c'GIT_DIFF_INCLUDE_UNMODIFIED :: (Num a) => a

{-# LINE 48 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_RECURSE_UNTRACKED_DIRS = 1024
c'GIT_DIFF_RECURSE_UNTRACKED_DIRS :: (Num a) => a

{-# LINE 49 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_DISABLE_PATHSPEC_MATCH = 2048
c'GIT_DIFF_DISABLE_PATHSPEC_MATCH :: (Num a) => a

{-# LINE 50 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_DELTAS_ARE_ICASE = 4096
c'GIT_DIFF_DELTAS_ARE_ICASE :: (Num a) => a

{-# LINE 51 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_UNTRACKED_CONTENT = 8192
c'GIT_DIFF_INCLUDE_UNTRACKED_CONTENT :: (Num a) => a

{-# LINE 52 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_SKIP_BINARY_CHECK = 16384
c'GIT_DIFF_SKIP_BINARY_CHECK :: (Num a) => a

{-# LINE 53 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_TYPECHANGE = 32768
c'GIT_DIFF_INCLUDE_TYPECHANGE :: (Num a) => a

{-# LINE 54 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_INCLUDE_TYPECHANGE_TREES = 65536
c'GIT_DIFF_INCLUDE_TYPECHANGE_TREES :: (Num a) => a

{-# LINE 55 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_IGNORE_FILEMODE = 131072
c'GIT_DIFF_IGNORE_FILEMODE :: (Num a) => a

{-# LINE 56 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_RECURSE_IGNORED_DIRS = 262144
c'GIT_DIFF_RECURSE_IGNORED_DIRS :: (Num a) => a

{-# LINE 57 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct git_diff_list git_diff_list; -}
data C'git_diff_list = C'git_diff_list

{-# LINE 59 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef enum {
            GIT_DIFF_FLAG_BINARY = 1 << 0,
            GIT_DIFF_FLAG_NOT_BINARY = 1 << 1,
            GIT_DIFF_FLAG_VALID_OID = 1 << 2
        } git_diff_flag_t; -}
type C'git_diff_flag_t = CUInt

{-# LINE 65 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FLAG_BINARY = 1
c'GIT_DIFF_FLAG_BINARY :: (Num a) => a

{-# LINE 66 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FLAG_NOT_BINARY = 2
c'GIT_DIFF_FLAG_NOT_BINARY :: (Num a) => a

{-# LINE 67 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FLAG_VALID_OID = 4
c'GIT_DIFF_FLAG_VALID_OID :: (Num a) => a

{-# LINE 68 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef enum {
            GIT_DELTA_UNMODIFIED = 0,
            GIT_DELTA_ADDED = 1,
            GIT_DELTA_DELETED = 2,
            GIT_DELTA_MODIFIED = 3,
            GIT_DELTA_RENAMED = 4,
            GIT_DELTA_COPIED = 5,
            GIT_DELTA_IGNORED = 6,
            GIT_DELTA_UNTRACKED = 7,
            GIT_DELTA_TYPECHANGE = 8
        } git_delta_t; -}
type C'git_delta_t = CUInt

{-# LINE 80 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_UNMODIFIED = 0
c'GIT_DELTA_UNMODIFIED :: (Num a) => a

{-# LINE 81 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_ADDED = 1
c'GIT_DELTA_ADDED :: (Num a) => a

{-# LINE 82 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_DELETED = 2
c'GIT_DELTA_DELETED :: (Num a) => a

{-# LINE 83 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_MODIFIED = 3
c'GIT_DELTA_MODIFIED :: (Num a) => a

{-# LINE 84 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_RENAMED = 4
c'GIT_DELTA_RENAMED :: (Num a) => a

{-# LINE 85 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_COPIED = 5
c'GIT_DELTA_COPIED :: (Num a) => a

{-# LINE 86 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_IGNORED = 6
c'GIT_DELTA_IGNORED :: (Num a) => a

{-# LINE 87 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_UNTRACKED = 7
c'GIT_DELTA_UNTRACKED :: (Num a) => a

{-# LINE 88 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DELTA_TYPECHANGE = 8
c'GIT_DELTA_TYPECHANGE :: (Num a) => a

{-# LINE 89 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            git_oid oid;
            const char * path;
            git_off_t size;
            uint32_t flags;
            uint16_t mode;
        } git_diff_file; -}

{-# LINE 97 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 98 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 99 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 100 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 101 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 102 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_file = C'git_diff_file{
  c'git_diff_file'oid :: C'git_oid,
  c'git_diff_file'path :: CString,
  c'git_diff_file'size :: CLong,
  c'git_diff_file'flags :: CUInt,
  c'git_diff_file'mode :: CUShort
} deriving (Eq,Show)
p'git_diff_file'oid p = plusPtr p 0
p'git_diff_file'oid :: Ptr (C'git_diff_file) -> Ptr (C'git_oid)
p'git_diff_file'path p = plusPtr p 24
p'git_diff_file'path :: Ptr (C'git_diff_file) -> Ptr (CString)
p'git_diff_file'size p = plusPtr p 32
p'git_diff_file'size :: Ptr (C'git_diff_file) -> Ptr (CLong)
p'git_diff_file'flags p = plusPtr p 40
p'git_diff_file'flags :: Ptr (C'git_diff_file) -> Ptr (CUInt)
p'git_diff_file'mode p = plusPtr p 44
p'git_diff_file'mode :: Ptr (C'git_diff_file) -> Ptr (CUShort)
instance Storable C'git_diff_file where
  sizeOf _ = 48
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 24
    v2 <- peekByteOff p 32
    v3 <- peekByteOff p 40
    v4 <- peekByteOff p 44
    return $ C'git_diff_file v0 v1 v2 v3 v4
  poke p (C'git_diff_file v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 24 v1
    pokeByteOff p 32 v2
    pokeByteOff p 40 v3
    pokeByteOff p 44 v4
    return ()

{-# LINE 103 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            git_diff_file old_file;
            git_diff_file new_file;
            git_delta_t status;
            uint32_t similarity;
            uint32_t flags;
        } git_diff_delta; -}

{-# LINE 111 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 112 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 113 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 114 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 115 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 116 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_delta = C'git_diff_delta{
  c'git_diff_delta'old_file :: C'git_diff_file,
  c'git_diff_delta'new_file :: C'git_diff_file,
  c'git_diff_delta'status :: C'git_delta_t,
  c'git_diff_delta'similarity :: CUInt,
  c'git_diff_delta'flags :: CUInt
} deriving (Eq,Show)
p'git_diff_delta'old_file p = plusPtr p 0
p'git_diff_delta'old_file :: Ptr (C'git_diff_delta) -> Ptr (C'git_diff_file)
p'git_diff_delta'new_file p = plusPtr p 48
p'git_diff_delta'new_file :: Ptr (C'git_diff_delta) -> Ptr (C'git_diff_file)
p'git_diff_delta'status p = plusPtr p 96
p'git_diff_delta'status :: Ptr (C'git_diff_delta) -> Ptr (C'git_delta_t)
p'git_diff_delta'similarity p = plusPtr p 100
p'git_diff_delta'similarity :: Ptr (C'git_diff_delta) -> Ptr (CUInt)
p'git_diff_delta'flags p = plusPtr p 104
p'git_diff_delta'flags :: Ptr (C'git_diff_delta) -> Ptr (CUInt)
instance Storable C'git_diff_delta where
  sizeOf _ = 112
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 48
    v2 <- peekByteOff p 96
    v3 <- peekByteOff p 100
    v4 <- peekByteOff p 104
    return $ C'git_diff_delta v0 v1 v2 v3 v4
  poke p (C'git_diff_delta v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 48 v1
    pokeByteOff p 96 v2
    pokeByteOff p 100 v3
    pokeByteOff p 104 v4
    return ()

{-# LINE 117 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_notify_cb)(const git_diff_list * diff_so_far,
                                   const git_diff_delta * delta_to_add,
                                   const char * matched_pathspec,
                                   void * payload); -}
type C'git_diff_notify_cb = FunPtr (Ptr (C'git_diff_list) -> Ptr (C'git_diff_delta) -> CString -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_notify_cb
  :: (Ptr (C'git_diff_list) -> Ptr (C'git_diff_delta) -> CString -> Ptr () -> IO CInt) -> IO C'git_diff_notify_cb
foreign import ccall "dynamic" mK'git_diff_notify_cb
  :: C'git_diff_notify_cb -> (Ptr (C'git_diff_list) -> Ptr (C'git_diff_delta) -> CString -> Ptr () -> IO CInt)

{-# LINE 122 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            unsigned int version;
            uint32_t flags;
            uint16_t context_lines;
            uint16_t interhunk_lines;
            const char * old_prefix;
            const char * new_prefix;
            git_strarray pathspec;
            git_off_t max_size;
            git_diff_notify_cb notify_cb;
            void * notify_payload;
        } git_diff_options; -}

{-# LINE 135 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 136 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 137 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 138 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 139 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 140 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 141 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 142 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 143 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 144 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 145 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_options = C'git_diff_options{
  c'git_diff_options'version :: CUInt,
  c'git_diff_options'flags :: CUInt,
  c'git_diff_options'context_lines :: CUShort,
  c'git_diff_options'interhunk_lines :: CUShort,
  c'git_diff_options'old_prefix :: CString,
  c'git_diff_options'new_prefix :: CString,
  c'git_diff_options'pathspec :: C'git_strarray,
  c'git_diff_options'max_size :: CLong,
  c'git_diff_options'notify_cb :: C'git_diff_notify_cb,
  c'git_diff_options'notify_payload :: Ptr ()
} deriving (Eq,Show)
p'git_diff_options'version p = plusPtr p 0
p'git_diff_options'version :: Ptr (C'git_diff_options) -> Ptr (CUInt)
p'git_diff_options'flags p = plusPtr p 4
p'git_diff_options'flags :: Ptr (C'git_diff_options) -> Ptr (CUInt)
p'git_diff_options'context_lines p = plusPtr p 8
p'git_diff_options'context_lines :: Ptr (C'git_diff_options) -> Ptr (CUShort)
p'git_diff_options'interhunk_lines p = plusPtr p 10
p'git_diff_options'interhunk_lines :: Ptr (C'git_diff_options) -> Ptr (CUShort)
p'git_diff_options'old_prefix p = plusPtr p 16
p'git_diff_options'old_prefix :: Ptr (C'git_diff_options) -> Ptr (CString)
p'git_diff_options'new_prefix p = plusPtr p 24
p'git_diff_options'new_prefix :: Ptr (C'git_diff_options) -> Ptr (CString)
p'git_diff_options'pathspec p = plusPtr p 32
p'git_diff_options'pathspec :: Ptr (C'git_diff_options) -> Ptr (C'git_strarray)
p'git_diff_options'max_size p = plusPtr p 48
p'git_diff_options'max_size :: Ptr (C'git_diff_options) -> Ptr (CLong)
p'git_diff_options'notify_cb p = plusPtr p 56
p'git_diff_options'notify_cb :: Ptr (C'git_diff_options) -> Ptr (C'git_diff_notify_cb)
p'git_diff_options'notify_payload p = plusPtr p 64
p'git_diff_options'notify_payload :: Ptr (C'git_diff_options) -> Ptr (Ptr ())
instance Storable C'git_diff_options where
  sizeOf _ = 72
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 10
    v4 <- peekByteOff p 16
    v5 <- peekByteOff p 24
    v6 <- peekByteOff p 32
    v7 <- peekByteOff p 48
    v8 <- peekByteOff p 56
    v9 <- peekByteOff p 64
    return $ C'git_diff_options v0 v1 v2 v3 v4 v5 v6 v7 v8 v9
  poke p (C'git_diff_options v0 v1 v2 v3 v4 v5 v6 v7 v8 v9) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 10 v3
    pokeByteOff p 16 v4
    pokeByteOff p 24 v5
    pokeByteOff p 32 v6
    pokeByteOff p 48 v7
    pokeByteOff p 56 v8
    pokeByteOff p 64 v9
    return ()

{-# LINE 146 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_file_cb)(const git_diff_delta * delta,
                                 float progress,
                                 void * payload); -}
type C'git_diff_file_cb = FunPtr (Ptr (C'git_diff_delta) -> CFloat -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_file_cb
  :: (Ptr (C'git_diff_delta) -> CFloat -> Ptr () -> IO CInt) -> IO C'git_diff_file_cb
foreign import ccall "dynamic" mK'git_diff_file_cb
  :: C'git_diff_file_cb -> (Ptr (C'git_diff_delta) -> CFloat -> Ptr () -> IO CInt)

{-# LINE 150 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            int old_start; int old_lines; int new_start; int new_lines;
        } git_diff_range; -}

{-# LINE 154 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 155 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 156 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 157 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 158 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_range = C'git_diff_range{
  c'git_diff_range'old_start :: CInt,
  c'git_diff_range'old_lines :: CInt,
  c'git_diff_range'new_start :: CInt,
  c'git_diff_range'new_lines :: CInt
} deriving (Eq,Show)
p'git_diff_range'old_start p = plusPtr p 0
p'git_diff_range'old_start :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'old_lines p = plusPtr p 4
p'git_diff_range'old_lines :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'new_start p = plusPtr p 8
p'git_diff_range'new_start :: Ptr (C'git_diff_range) -> Ptr (CInt)
p'git_diff_range'new_lines p = plusPtr p 12
p'git_diff_range'new_lines :: Ptr (C'git_diff_range) -> Ptr (CInt)
instance Storable C'git_diff_range where
  sizeOf _ = 16
  alignment _ = 4
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    return $ C'git_diff_range v0 v1 v2 v3
  poke p (C'git_diff_range v0 v1 v2 v3) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    return ()

{-# LINE 159 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_hunk_cb)(const git_diff_delta * delta,
                                 const git_diff_range * range,
                                 const char * header,
                                 size_t header_len,
                                 void * payload); -}
type C'git_diff_hunk_cb = FunPtr (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CString -> CSize -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_hunk_cb
  :: (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CString -> CSize -> Ptr () -> IO CInt) -> IO C'git_diff_hunk_cb
foreign import ccall "dynamic" mK'git_diff_hunk_cb
  :: C'git_diff_hunk_cb -> (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CString -> CSize -> Ptr () -> IO CInt)

{-# LINE 165 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef enum {
            GIT_DIFF_LINE_CONTEXT = ' ',
            GIT_DIFF_LINE_ADDITION = '+',
            GIT_DIFF_LINE_DELETION = '-',
            GIT_DIFF_LINE_ADD_EOFNL = '\n',
            GIT_DIFF_LINE_DEL_EOFNL = '\0',
            GIT_DIFF_LINE_FILE_HDR = 'F',
            GIT_DIFF_LINE_HUNK_HDR = 'H',
            GIT_DIFF_LINE_BINARY = 'B'
        } git_diff_line_t; -}
type C'git_diff_line_t = CUInt

{-# LINE 176 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_CONTEXT = 32
c'GIT_DIFF_LINE_CONTEXT :: (Num a) => a

{-# LINE 177 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_ADDITION = 43
c'GIT_DIFF_LINE_ADDITION :: (Num a) => a

{-# LINE 178 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_DELETION = 45
c'GIT_DIFF_LINE_DELETION :: (Num a) => a

{-# LINE 179 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_ADD_EOFNL = 10
c'GIT_DIFF_LINE_ADD_EOFNL :: (Num a) => a

{-# LINE 180 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_DEL_EOFNL = 0
c'GIT_DIFF_LINE_DEL_EOFNL :: (Num a) => a

{-# LINE 181 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_FILE_HDR = 70
c'GIT_DIFF_LINE_FILE_HDR :: (Num a) => a

{-# LINE 182 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_HUNK_HDR = 72
c'GIT_DIFF_LINE_HUNK_HDR :: (Num a) => a

{-# LINE 183 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_LINE_BINARY = 66
c'GIT_DIFF_LINE_BINARY :: (Num a) => a

{-# LINE 184 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef int (* git_diff_data_cb)(const git_diff_delta * delta,
                                 const git_diff_range * range,
                                 char line_origin,
                                 const char * content,
                                 size_t content_len,
                                 void * payload); -}
type C'git_diff_data_cb = FunPtr (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CChar -> CString -> CSize -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_data_cb
  :: (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CChar -> CString -> CSize -> Ptr () -> IO CInt) -> IO C'git_diff_data_cb
foreign import ccall "dynamic" mK'git_diff_data_cb
  :: C'git_diff_data_cb -> (Ptr (C'git_diff_delta) -> Ptr (C'git_diff_range) -> CChar -> CString -> CSize -> Ptr () -> IO CInt)

{-# LINE 191 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct git_diff_patch git_diff_patch; -}
data C'git_diff_patch = C'git_diff_patch

{-# LINE 193 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef enum {
            GIT_DIFF_FIND_RENAMES = 1 << 0,
            GIT_DIFF_FIND_RENAMES_FROM_REWRITES = 1 << 1,
            GIT_DIFF_FIND_COPIES = 1 << 2,
            GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED = 1 << 3,
            GIT_DIFF_FIND_AND_BREAK_REWRITES = 1 << 4,
            GIT_DIFF_FIND_ALL = 0x1f,
            GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE = 0,
            GIT_DIFF_FIND_IGNORE_WHITESPACE = 1 << 6,
            GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE = 1 << 7
        } git_diff_find_t; -}
type C'git_diff_find_t = CUInt

{-# LINE 205 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_RENAMES = 1
c'GIT_DIFF_FIND_RENAMES :: (Num a) => a

{-# LINE 206 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_RENAMES_FROM_REWRITES = 2
c'GIT_DIFF_FIND_RENAMES_FROM_REWRITES :: (Num a) => a

{-# LINE 207 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_COPIES = 4
c'GIT_DIFF_FIND_COPIES :: (Num a) => a

{-# LINE 208 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED = 8
c'GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED :: (Num a) => a

{-# LINE 209 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_AND_BREAK_REWRITES = 16
c'GIT_DIFF_FIND_AND_BREAK_REWRITES :: (Num a) => a

{-# LINE 210 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_ALL = 31
c'GIT_DIFF_FIND_ALL :: (Num a) => a

{-# LINE 211 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE = 0
c'GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE :: (Num a) => a

{-# LINE 212 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_IGNORE_WHITESPACE = 64
c'GIT_DIFF_FIND_IGNORE_WHITESPACE :: (Num a) => a

{-# LINE 213 "Bindings/Libgit2/Diff.hsc" #-}
c'GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE = 128
c'GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE :: (Num a) => a

{-# LINE 214 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            int (* file_signature)(void * * out,
                                   const git_diff_file * file,
                                   const char * fullpath,
                                   void * payload);
            int (* buffer_signature)(void * * out,
                                     const git_diff_file * file,
                                     const char * buf,
                                     size_t buflen,
                                     void * payload);
            void (* free_signature)(void * sig, void * payload);
            int (* similarity)(int * score,
                               void * siga,
                               void * sigb,
                               void * payload);
            void * payload;
        } git_diff_similarity_metric; -}
type C'git_diff_similarity_metric_file_signature_callback = FunPtr (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_similarity_metric_file_signature_callback
  :: (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> Ptr () -> IO CInt) -> IO C'git_diff_similarity_metric_file_signature_callback
foreign import ccall "dynamic" mK'git_diff_similarity_metric_file_signature_callback
  :: C'git_diff_similarity_metric_file_signature_callback -> (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> Ptr () -> IO CInt)

{-# LINE 232 "Bindings/Libgit2/Diff.hsc" #-}
type C'git_diff_similarity_metric_buffer_signature_callback = FunPtr (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> CSize -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_similarity_metric_buffer_signature_callback
  :: (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> CSize -> Ptr () -> IO CInt) -> IO C'git_diff_similarity_metric_buffer_signature_callback
foreign import ccall "dynamic" mK'git_diff_similarity_metric_buffer_signature_callback
  :: C'git_diff_similarity_metric_buffer_signature_callback -> (Ptr (Ptr ()) -> Ptr C'git_diff_file -> CString -> CSize -> Ptr () -> IO CInt)

{-# LINE 233 "Bindings/Libgit2/Diff.hsc" #-}
type C'git_diff_similarity_metric_free_signature_callback = FunPtr (Ptr () -> Ptr () -> IO ())
foreign import ccall "wrapper" mk'git_diff_similarity_metric_free_signature_callback
  :: (Ptr () -> Ptr () -> IO ()) -> IO C'git_diff_similarity_metric_free_signature_callback
foreign import ccall "dynamic" mK'git_diff_similarity_metric_free_signature_callback
  :: C'git_diff_similarity_metric_free_signature_callback -> (Ptr () -> Ptr () -> IO ())

{-# LINE 234 "Bindings/Libgit2/Diff.hsc" #-}
type C'git_diff_similarity_metric_similarity_callback = FunPtr (Ptr CInt -> Ptr () -> Ptr () -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_diff_similarity_metric_similarity_callback
  :: (Ptr CInt -> Ptr () -> Ptr () -> Ptr () -> IO CInt) -> IO C'git_diff_similarity_metric_similarity_callback
foreign import ccall "dynamic" mK'git_diff_similarity_metric_similarity_callback
  :: C'git_diff_similarity_metric_similarity_callback -> (Ptr CInt -> Ptr () -> Ptr () -> Ptr () -> IO CInt)

{-# LINE 235 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 236 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 237 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 238 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 239 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 240 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 241 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_similarity_metric = C'git_diff_similarity_metric{
  c'git_diff_similarity_metric'file_signature :: C'git_diff_similarity_metric_file_signature_callback,
  c'git_diff_similarity_metric'buffer_signature :: C'git_diff_similarity_metric_buffer_signature_callback,
  c'git_diff_similarity_metric'free_signature :: C'git_diff_similarity_metric_free_signature_callback,
  c'git_diff_similarity_metric'similarity :: C'git_diff_similarity_metric_similarity_callback,
  c'git_diff_similarity_metric'payload :: Ptr ()
} deriving (Eq,Show)
p'git_diff_similarity_metric'file_signature p = plusPtr p 0
p'git_diff_similarity_metric'file_signature :: Ptr (C'git_diff_similarity_metric) -> Ptr (C'git_diff_similarity_metric_file_signature_callback)
p'git_diff_similarity_metric'buffer_signature p = plusPtr p 8
p'git_diff_similarity_metric'buffer_signature :: Ptr (C'git_diff_similarity_metric) -> Ptr (C'git_diff_similarity_metric_buffer_signature_callback)
p'git_diff_similarity_metric'free_signature p = plusPtr p 16
p'git_diff_similarity_metric'free_signature :: Ptr (C'git_diff_similarity_metric) -> Ptr (C'git_diff_similarity_metric_free_signature_callback)
p'git_diff_similarity_metric'similarity p = plusPtr p 24
p'git_diff_similarity_metric'similarity :: Ptr (C'git_diff_similarity_metric) -> Ptr (C'git_diff_similarity_metric_similarity_callback)
p'git_diff_similarity_metric'payload p = plusPtr p 32
p'git_diff_similarity_metric'payload :: Ptr (C'git_diff_similarity_metric) -> Ptr (Ptr ())
instance Storable C'git_diff_similarity_metric where
  sizeOf _ = 40
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    v3 <- peekByteOff p 24
    v4 <- peekByteOff p 32
    return $ C'git_diff_similarity_metric v0 v1 v2 v3 v4
  poke p (C'git_diff_similarity_metric v0 v1 v2 v3 v4) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    pokeByteOff p 24 v3
    pokeByteOff p 32 v4
    return ()

{-# LINE 242 "Bindings/Libgit2/Diff.hsc" #-}
{- typedef struct {
            unsigned int version;
            unsigned int flags;
            unsigned int rename_threshold;
            unsigned int rename_from_rewrite_threshold;
            unsigned int copy_threshold;
            unsigned int break_rewrite_threshold;
            unsigned int target_limit;
            git_diff_similarity_metric * metric;
        } git_diff_find_options; -}

{-# LINE 253 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 254 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 255 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 256 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 257 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 258 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 259 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 260 "Bindings/Libgit2/Diff.hsc" #-}

{-# LINE 261 "Bindings/Libgit2/Diff.hsc" #-}
data C'git_diff_find_options = C'git_diff_find_options{
  c'git_diff_find_options'version :: CUInt,
  c'git_diff_find_options'flags :: CUInt,
  c'git_diff_find_options'rename_threshold :: CUInt,
  c'git_diff_find_options'rename_from_rewrite_threshold :: CUInt,
  c'git_diff_find_options'copy_threshold :: CUInt,
  c'git_diff_find_options'break_rewrite_threshold :: CUInt,
  c'git_diff_find_options'target_limit :: CUInt,
  c'git_diff_find_options'metric :: Ptr C'git_diff_similarity_metric
} deriving (Eq,Show)
p'git_diff_find_options'version p = plusPtr p 0
p'git_diff_find_options'version :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'flags p = plusPtr p 4
p'git_diff_find_options'flags :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'rename_threshold p = plusPtr p 8
p'git_diff_find_options'rename_threshold :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'rename_from_rewrite_threshold p = plusPtr p 12
p'git_diff_find_options'rename_from_rewrite_threshold :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'copy_threshold p = plusPtr p 16
p'git_diff_find_options'copy_threshold :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'break_rewrite_threshold p = plusPtr p 20
p'git_diff_find_options'break_rewrite_threshold :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'target_limit p = plusPtr p 24
p'git_diff_find_options'target_limit :: Ptr (C'git_diff_find_options) -> Ptr (CUInt)
p'git_diff_find_options'metric p = plusPtr p 32
p'git_diff_find_options'metric :: Ptr (C'git_diff_find_options) -> Ptr (Ptr C'git_diff_similarity_metric)
instance Storable C'git_diff_find_options where
  sizeOf _ = 40
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 4
    v2 <- peekByteOff p 8
    v3 <- peekByteOff p 12
    v4 <- peekByteOff p 16
    v5 <- peekByteOff p 20
    v6 <- peekByteOff p 24
    v7 <- peekByteOff p 32
    return $ C'git_diff_find_options v0 v1 v2 v3 v4 v5 v6 v7
  poke p (C'git_diff_find_options v0 v1 v2 v3 v4 v5 v6 v7) = do
    pokeByteOff p 0 v0
    pokeByteOff p 4 v1
    pokeByteOff p 8 v2
    pokeByteOff p 12 v3
    pokeByteOff p 16 v4
    pokeByteOff p 20 v5
    pokeByteOff p 24 v6
    pokeByteOff p 32 v7
    return ()

{-# LINE 262 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_list_free" c'git_diff_list_free
  :: Ptr C'git_diff_list -> IO ()
foreign import ccall "&git_diff_list_free" p'git_diff_list_free
  :: FunPtr (Ptr C'git_diff_list -> IO ())

{-# LINE 263 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_tree_to_tree" c'git_diff_tree_to_tree
  :: Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_tree -> Ptr C'git_diff_options -> IO (CInt)
foreign import ccall "&git_diff_tree_to_tree" p'git_diff_tree_to_tree
  :: FunPtr (Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_tree -> Ptr C'git_diff_options -> IO (CInt))

{-# LINE 264 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_tree_to_index" c'git_diff_tree_to_index
  :: Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_index -> Ptr C'git_diff_options -> IO (CInt)
foreign import ccall "&git_diff_tree_to_index" p'git_diff_tree_to_index
  :: FunPtr (Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_index -> Ptr C'git_diff_options -> IO (CInt))

{-# LINE 265 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_index_to_workdir" c'git_diff_index_to_workdir
  :: Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_index -> Ptr C'git_diff_options -> IO (CInt)
foreign import ccall "&git_diff_index_to_workdir" p'git_diff_index_to_workdir
  :: FunPtr (Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_index -> Ptr C'git_diff_options -> IO (CInt))

{-# LINE 266 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_tree_to_workdir" c'git_diff_tree_to_workdir
  :: Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_diff_options -> IO (CInt)
foreign import ccall "&git_diff_tree_to_workdir" p'git_diff_tree_to_workdir
  :: FunPtr (Ptr (Ptr C'git_diff_list) -> Ptr C'git_repository -> Ptr C'git_tree -> Ptr C'git_diff_options -> IO (CInt))

{-# LINE 267 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_merge" c'git_diff_merge
  :: Ptr C'git_diff_list -> Ptr C'git_diff_list -> IO (CInt)
foreign import ccall "&git_diff_merge" p'git_diff_merge
  :: FunPtr (Ptr C'git_diff_list -> Ptr C'git_diff_list -> IO (CInt))

{-# LINE 268 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_find_similar" c'git_diff_find_similar
  :: Ptr C'git_diff_list -> Ptr C'git_diff_find_options -> IO (CInt)
foreign import ccall "&git_diff_find_similar" p'git_diff_find_similar
  :: FunPtr (Ptr C'git_diff_list -> Ptr C'git_diff_find_options -> IO (CInt))

{-# LINE 269 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_foreach" c'git_diff_foreach
  :: Ptr C'git_diff_list -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_foreach" p'git_diff_foreach
  :: FunPtr (Ptr C'git_diff_list -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 270 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_print_compact" c'git_diff_print_compact
  :: Ptr C'git_diff_list -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_print_compact" p'git_diff_print_compact
  :: FunPtr (Ptr C'git_diff_list -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 271 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_status_char" c'git_diff_status_char
  :: C'git_delta_t -> IO (CChar)
foreign import ccall "&git_diff_status_char" p'git_diff_status_char
  :: FunPtr (C'git_delta_t -> IO (CChar))

{-# LINE 272 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_print_patch" c'git_diff_print_patch
  :: Ptr C'git_diff_list -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_print_patch" p'git_diff_print_patch
  :: FunPtr (Ptr C'git_diff_list -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 273 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_num_deltas" c'git_diff_num_deltas
  :: Ptr C'git_diff_list -> IO (CSize)
foreign import ccall "&git_diff_num_deltas" p'git_diff_num_deltas
  :: FunPtr (Ptr C'git_diff_list -> IO (CSize))

{-# LINE 274 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_num_deltas_of_type" c'git_diff_num_deltas_of_type
  :: Ptr C'git_diff_list -> C'git_delta_t -> IO (CSize)
foreign import ccall "&git_diff_num_deltas_of_type" p'git_diff_num_deltas_of_type
  :: FunPtr (Ptr C'git_diff_list -> C'git_delta_t -> IO (CSize))

{-# LINE 275 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_get_patch" c'git_diff_get_patch
  :: Ptr (Ptr C'git_diff_patch) -> Ptr (Ptr C'git_diff_delta) -> Ptr C'git_diff_list -> CSize -> IO (CInt)
foreign import ccall "&git_diff_get_patch" p'git_diff_get_patch
  :: FunPtr (Ptr (Ptr C'git_diff_patch) -> Ptr (Ptr C'git_diff_delta) -> Ptr C'git_diff_list -> CSize -> IO (CInt))

{-# LINE 276 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_free" c'git_diff_patch_free
  :: Ptr C'git_diff_patch -> IO ()
foreign import ccall "&git_diff_patch_free" p'git_diff_patch_free
  :: FunPtr (Ptr C'git_diff_patch -> IO ())

{-# LINE 277 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_delta" c'git_diff_patch_delta
  :: Ptr C'git_diff_patch -> IO (Ptr C'git_diff_delta)
foreign import ccall "&git_diff_patch_delta" p'git_diff_patch_delta
  :: FunPtr (Ptr C'git_diff_patch -> IO (Ptr C'git_diff_delta))

{-# LINE 278 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_num_hunks" c'git_diff_patch_num_hunks
  :: Ptr C'git_diff_patch -> IO (CSize)
foreign import ccall "&git_diff_patch_num_hunks" p'git_diff_patch_num_hunks
  :: FunPtr (Ptr C'git_diff_patch -> IO (CSize))

{-# LINE 279 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_line_stats" c'git_diff_patch_line_stats
  :: Ptr CSize -> Ptr CSize -> Ptr CSize -> Ptr C'git_diff_patch -> IO (CInt)
foreign import ccall "&git_diff_patch_line_stats" p'git_diff_patch_line_stats
  :: FunPtr (Ptr CSize -> Ptr CSize -> Ptr CSize -> Ptr C'git_diff_patch -> IO (CInt))

{-# LINE 280 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_get_hunk" c'git_diff_patch_get_hunk
  :: Ptr (Ptr C'git_diff_range) -> Ptr (CString) -> Ptr CSize -> Ptr CSize -> Ptr C'git_diff_patch -> CSize -> IO (CInt)
foreign import ccall "&git_diff_patch_get_hunk" p'git_diff_patch_get_hunk
  :: FunPtr (Ptr (Ptr C'git_diff_range) -> Ptr (CString) -> Ptr CSize -> Ptr CSize -> Ptr C'git_diff_patch -> CSize -> IO (CInt))

{-# LINE 281 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_num_lines_in_hunk" c'git_diff_patch_num_lines_in_hunk
  :: Ptr C'git_diff_patch -> CSize -> IO (CInt)
foreign import ccall "&git_diff_patch_num_lines_in_hunk" p'git_diff_patch_num_lines_in_hunk
  :: FunPtr (Ptr C'git_diff_patch -> CSize -> IO (CInt))

{-# LINE 282 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_get_line_in_hunk" c'git_diff_patch_get_line_in_hunk
  :: CString -> Ptr (CString) -> Ptr CSize -> Ptr CInt -> Ptr CInt -> Ptr C'git_diff_patch -> CSize -> CSize -> IO (CInt)
foreign import ccall "&git_diff_patch_get_line_in_hunk" p'git_diff_patch_get_line_in_hunk
  :: FunPtr (CString -> Ptr (CString) -> Ptr CSize -> Ptr CInt -> Ptr CInt -> Ptr C'git_diff_patch -> CSize -> CSize -> IO (CInt))

{-# LINE 283 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_print" c'git_diff_patch_print
  :: Ptr C'git_diff_patch -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_patch_print" p'git_diff_patch_print
  :: FunPtr (Ptr C'git_diff_patch -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 284 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_patch_to_str" c'git_diff_patch_to_str
  :: Ptr (CString) -> Ptr C'git_diff_patch -> IO (CInt)
foreign import ccall "&git_diff_patch_to_str" p'git_diff_patch_to_str
  :: FunPtr (Ptr (CString) -> Ptr C'git_diff_patch -> IO (CInt))

{-# LINE 285 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_blobs" c'git_diff_blobs
  :: Ptr C'git_blob -> Ptr C'git_blob -> Ptr C'git_diff_options -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_blobs" p'git_diff_blobs
  :: FunPtr (Ptr C'git_blob -> Ptr C'git_blob -> Ptr C'git_diff_options -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 286 "Bindings/Libgit2/Diff.hsc" #-}
foreign import ccall "git_diff_blob_to_buffer" c'git_diff_blob_to_buffer
  :: Ptr C'git_blob -> CString -> CSize -> Ptr C'git_diff_options -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt)
foreign import ccall "&git_diff_blob_to_buffer" p'git_diff_blob_to_buffer
  :: FunPtr (Ptr C'git_blob -> CString -> CSize -> Ptr C'git_diff_options -> C'git_diff_file_cb -> C'git_diff_hunk_cb -> C'git_diff_data_cb -> Ptr () -> IO (CInt))

{-# LINE 287 "Bindings/Libgit2/Diff.hsc" #-}