{-# LANGUAGE DeriveDataTypeable #-}
{-# OPTIONS_GHC -fno-warn-missing-fields #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-----------------------------------------------------------------
-- Autogenerated by Thrift                                     --
--                                                             --
-- DO NOT EDIT UNLESS YOU ARE SURE YOU KNOW WHAT YOU ARE DOING --
-----------------------------------------------------------------

module Database.Cassandra.Thrift.Cassandra where
import Prelude ( Bool(..), Enum, Double, String, Maybe(..),
                 Eq, Show, Ord,
                 return, length, IO, fromIntegral, fromEnum, toEnum,
                 (&&), (||), (==), (++), ($), (-) )

import Control.Exception
import Data.ByteString.Lazy
import Data.Int
import Data.Typeable ( Typeable )
import qualified Data.Map as Map
import qualified Data.Set as Set

import Thrift


import Database.Cassandra.Thrift.Cassandra_Types
import qualified Database.Cassandra.Thrift.Cassandra_Iface as Iface
-- HELPER FUNCTIONS AND STRUCTURES --

data Login_args = Login_args{f_Login_args_auth_request :: Maybe AuthenticationRequest} deriving (Show,Eq,Ord,Typeable)
write_Login_args oprot record = do
  writeStructBegin oprot "Login_args"
  case f_Login_args_auth_request record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("auth_request",T_STRUCT,1)
    write_AuthenticationRequest oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Login_args_fields iprot record = do
  (_,_t227,_id228) <- readFieldBegin iprot
  if _t227 == T_STOP then return record else
    case _id228 of 
      1 -> if _t227 == T_STRUCT then do
        s <- (read_AuthenticationRequest iprot)
        read_Login_args_fields iprot record{f_Login_args_auth_request=Just s}
        else do
          skip iprot _t227
          read_Login_args_fields iprot record
      _ -> do
        skip iprot _t227
        readFieldEnd iprot
        read_Login_args_fields iprot record
read_Login_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Login_args_fields iprot (Login_args{f_Login_args_auth_request=Nothing})
  readStructEnd iprot
  return record
data Login_result = Login_result{f_Login_result_authnx :: Maybe AuthenticationException,f_Login_result_authzx :: Maybe AuthorizationException} deriving (Show,Eq,Ord,Typeable)
write_Login_result oprot record = do
  writeStructBegin oprot "Login_result"
  case f_Login_result_authnx record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("authnx",T_STRUCT,1)
    write_AuthenticationException oprot _v
    writeFieldEnd oprot}
  case f_Login_result_authzx record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("authzx",T_STRUCT,2)
    write_AuthorizationException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Login_result_fields iprot record = do
  (_,_t232,_id233) <- readFieldBegin iprot
  if _t232 == T_STOP then return record else
    case _id233 of 
      1 -> if _t232 == T_STRUCT then do
        s <- (read_AuthenticationException iprot)
        read_Login_result_fields iprot record{f_Login_result_authnx=Just s}
        else do
          skip iprot _t232
          read_Login_result_fields iprot record
      2 -> if _t232 == T_STRUCT then do
        s <- (read_AuthorizationException iprot)
        read_Login_result_fields iprot record{f_Login_result_authzx=Just s}
        else do
          skip iprot _t232
          read_Login_result_fields iprot record
      _ -> do
        skip iprot _t232
        readFieldEnd iprot
        read_Login_result_fields iprot record
read_Login_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Login_result_fields iprot (Login_result{f_Login_result_authnx=Nothing,f_Login_result_authzx=Nothing})
  readStructEnd iprot
  return record
data Set_keyspace_args = Set_keyspace_args{f_Set_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Set_keyspace_args oprot record = do
  writeStructBegin oprot "Set_keyspace_args"
  case f_Set_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keyspace",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Set_keyspace_args_fields iprot record = do
  (_,_t237,_id238) <- readFieldBegin iprot
  if _t237 == T_STOP then return record else
    case _id238 of 
      1 -> if _t237 == T_STRING then do
        s <- readString iprot
        read_Set_keyspace_args_fields iprot record{f_Set_keyspace_args_keyspace=Just s}
        else do
          skip iprot _t237
          read_Set_keyspace_args_fields iprot record
      _ -> do
        skip iprot _t237
        readFieldEnd iprot
        read_Set_keyspace_args_fields iprot record
read_Set_keyspace_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Set_keyspace_args_fields iprot (Set_keyspace_args{f_Set_keyspace_args_keyspace=Nothing})
  readStructEnd iprot
  return record
data Set_keyspace_result = Set_keyspace_result{f_Set_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Set_keyspace_result oprot record = do
  writeStructBegin oprot "Set_keyspace_result"
  case f_Set_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Set_keyspace_result_fields iprot record = do
  (_,_t242,_id243) <- readFieldBegin iprot
  if _t242 == T_STOP then return record else
    case _id243 of 
      1 -> if _t242 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Set_keyspace_result_fields iprot record{f_Set_keyspace_result_ire=Just s}
        else do
          skip iprot _t242
          read_Set_keyspace_result_fields iprot record
      _ -> do
        skip iprot _t242
        readFieldEnd iprot
        read_Set_keyspace_result_fields iprot record
read_Set_keyspace_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Set_keyspace_result_fields iprot (Set_keyspace_result{f_Set_keyspace_result_ire=Nothing})
  readStructEnd iprot
  return record
data Get_args = Get_args{f_Get_args_key :: Maybe ByteString,f_Get_args_column_path :: Maybe ColumnPath,f_Get_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_args oprot record = do
  writeStructBegin oprot "Get_args"
  case f_Get_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Get_args_column_path record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_path",T_STRUCT,2)
    write_ColumnPath oprot _v
    writeFieldEnd oprot}
  case f_Get_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,3)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_args_fields iprot record = do
  (_,_t247,_id248) <- readFieldBegin iprot
  if _t247 == T_STOP then return record else
    case _id248 of 
      1 -> if _t247 == T_STRING then do
        s <- readBinary iprot
        read_Get_args_fields iprot record{f_Get_args_key=Just s}
        else do
          skip iprot _t247
          read_Get_args_fields iprot record
      2 -> if _t247 == T_STRUCT then do
        s <- (read_ColumnPath iprot)
        read_Get_args_fields iprot record{f_Get_args_column_path=Just s}
        else do
          skip iprot _t247
          read_Get_args_fields iprot record
      3 -> if _t247 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Get_args_fields iprot record{f_Get_args_consistency_level=Just s}
        else do
          skip iprot _t247
          read_Get_args_fields iprot record
      _ -> do
        skip iprot _t247
        readFieldEnd iprot
        read_Get_args_fields iprot record
read_Get_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_args_fields iprot (Get_args{f_Get_args_key=Nothing,f_Get_args_column_path=Nothing,f_Get_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Get_result = Get_result{f_Get_result_success :: Maybe ColumnOrSuperColumn,f_Get_result_ire :: Maybe InvalidRequestException,f_Get_result_nfe :: Maybe NotFoundException,f_Get_result_ue :: Maybe UnavailableException,f_Get_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_result oprot record = do
  writeStructBegin oprot "Get_result"
  case f_Get_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRUCT,0)
    write_ColumnOrSuperColumn oprot _v
    writeFieldEnd oprot}
  case f_Get_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Get_result_nfe record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("nfe",T_STRUCT,2)
    write_NotFoundException oprot _v
    writeFieldEnd oprot}
  case f_Get_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,3)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Get_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,4)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_result_fields iprot record = do
  (_,_t252,_id253) <- readFieldBegin iprot
  if _t252 == T_STOP then return record else
    case _id253 of 
      0 -> if _t252 == T_STRUCT then do
        s <- (read_ColumnOrSuperColumn iprot)
        read_Get_result_fields iprot record{f_Get_result_success=Just s}
        else do
          skip iprot _t252
          read_Get_result_fields iprot record
      1 -> if _t252 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Get_result_fields iprot record{f_Get_result_ire=Just s}
        else do
          skip iprot _t252
          read_Get_result_fields iprot record
      2 -> if _t252 == T_STRUCT then do
        s <- (read_NotFoundException iprot)
        read_Get_result_fields iprot record{f_Get_result_nfe=Just s}
        else do
          skip iprot _t252
          read_Get_result_fields iprot record
      3 -> if _t252 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Get_result_fields iprot record{f_Get_result_ue=Just s}
        else do
          skip iprot _t252
          read_Get_result_fields iprot record
      4 -> if _t252 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Get_result_fields iprot record{f_Get_result_te=Just s}
        else do
          skip iprot _t252
          read_Get_result_fields iprot record
      _ -> do
        skip iprot _t252
        readFieldEnd iprot
        read_Get_result_fields iprot record
read_Get_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_result_fields iprot (Get_result{f_Get_result_success=Nothing,f_Get_result_ire=Nothing,f_Get_result_nfe=Nothing,f_Get_result_ue=Nothing,f_Get_result_te=Nothing})
  readStructEnd iprot
  return record
data Get_slice_args = Get_slice_args{f_Get_slice_args_key :: Maybe ByteString,f_Get_slice_args_column_parent :: Maybe ColumnParent,f_Get_slice_args_predicate :: Maybe SlicePredicate,f_Get_slice_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_slice_args oprot record = do
  writeStructBegin oprot "Get_slice_args"
  case f_Get_slice_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Get_slice_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Get_slice_args_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("predicate",T_STRUCT,3)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Get_slice_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_slice_args_fields iprot record = do
  (_,_t257,_id258) <- readFieldBegin iprot
  if _t257 == T_STOP then return record else
    case _id258 of 
      1 -> if _t257 == T_STRING then do
        s <- readBinary iprot
        read_Get_slice_args_fields iprot record{f_Get_slice_args_key=Just s}
        else do
          skip iprot _t257
          read_Get_slice_args_fields iprot record
      2 -> if _t257 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Get_slice_args_fields iprot record{f_Get_slice_args_column_parent=Just s}
        else do
          skip iprot _t257
          read_Get_slice_args_fields iprot record
      3 -> if _t257 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Get_slice_args_fields iprot record{f_Get_slice_args_predicate=Just s}
        else do
          skip iprot _t257
          read_Get_slice_args_fields iprot record
      4 -> if _t257 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Get_slice_args_fields iprot record{f_Get_slice_args_consistency_level=Just s}
        else do
          skip iprot _t257
          read_Get_slice_args_fields iprot record
      _ -> do
        skip iprot _t257
        readFieldEnd iprot
        read_Get_slice_args_fields iprot record
read_Get_slice_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_slice_args_fields iprot (Get_slice_args{f_Get_slice_args_key=Nothing,f_Get_slice_args_column_parent=Nothing,f_Get_slice_args_predicate=Nothing,f_Get_slice_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Get_slice_result = Get_slice_result{f_Get_slice_result_success :: Maybe [ColumnOrSuperColumn],f_Get_slice_result_ire :: Maybe InvalidRequestException,f_Get_slice_result_ue :: Maybe UnavailableException,f_Get_slice_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_slice_result oprot record = do
  writeStructBegin oprot "Get_slice_result"
  case f_Get_slice_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter261:t) = do {write_ColumnOrSuperColumn oprot _viter261;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Get_slice_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Get_slice_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Get_slice_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_slice_result_fields iprot record = do
  (_,_t263,_id264) <- readFieldBegin iprot
  if _t263 == T_STOP then return record else
    case _id264 of 
      0 -> if _t263 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- (read_ColumnOrSuperColumn iprot);r <- f (n-1); return $ v:r}} in do {(_etype268,_size265) <- readListBegin iprot; f _size265})
        read_Get_slice_result_fields iprot record{f_Get_slice_result_success=Just s}
        else do
          skip iprot _t263
          read_Get_slice_result_fields iprot record
      1 -> if _t263 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Get_slice_result_fields iprot record{f_Get_slice_result_ire=Just s}
        else do
          skip iprot _t263
          read_Get_slice_result_fields iprot record
      2 -> if _t263 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Get_slice_result_fields iprot record{f_Get_slice_result_ue=Just s}
        else do
          skip iprot _t263
          read_Get_slice_result_fields iprot record
      3 -> if _t263 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Get_slice_result_fields iprot record{f_Get_slice_result_te=Just s}
        else do
          skip iprot _t263
          read_Get_slice_result_fields iprot record
      _ -> do
        skip iprot _t263
        readFieldEnd iprot
        read_Get_slice_result_fields iprot record
read_Get_slice_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_slice_result_fields iprot (Get_slice_result{f_Get_slice_result_success=Nothing,f_Get_slice_result_ire=Nothing,f_Get_slice_result_ue=Nothing,f_Get_slice_result_te=Nothing})
  readStructEnd iprot
  return record
data Get_count_args = Get_count_args{f_Get_count_args_key :: Maybe ByteString,f_Get_count_args_column_parent :: Maybe ColumnParent,f_Get_count_args_predicate :: Maybe SlicePredicate,f_Get_count_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_count_args oprot record = do
  writeStructBegin oprot "Get_count_args"
  case f_Get_count_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Get_count_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Get_count_args_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("predicate",T_STRUCT,3)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Get_count_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_count_args_fields iprot record = do
  (_,_t273,_id274) <- readFieldBegin iprot
  if _t273 == T_STOP then return record else
    case _id274 of 
      1 -> if _t273 == T_STRING then do
        s <- readBinary iprot
        read_Get_count_args_fields iprot record{f_Get_count_args_key=Just s}
        else do
          skip iprot _t273
          read_Get_count_args_fields iprot record
      2 -> if _t273 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Get_count_args_fields iprot record{f_Get_count_args_column_parent=Just s}
        else do
          skip iprot _t273
          read_Get_count_args_fields iprot record
      3 -> if _t273 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Get_count_args_fields iprot record{f_Get_count_args_predicate=Just s}
        else do
          skip iprot _t273
          read_Get_count_args_fields iprot record
      4 -> if _t273 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Get_count_args_fields iprot record{f_Get_count_args_consistency_level=Just s}
        else do
          skip iprot _t273
          read_Get_count_args_fields iprot record
      _ -> do
        skip iprot _t273
        readFieldEnd iprot
        read_Get_count_args_fields iprot record
read_Get_count_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_count_args_fields iprot (Get_count_args{f_Get_count_args_key=Nothing,f_Get_count_args_column_parent=Nothing,f_Get_count_args_predicate=Nothing,f_Get_count_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Get_count_result = Get_count_result{f_Get_count_result_success :: Maybe Int32,f_Get_count_result_ire :: Maybe InvalidRequestException,f_Get_count_result_ue :: Maybe UnavailableException,f_Get_count_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_count_result oprot record = do
  writeStructBegin oprot "Get_count_result"
  case f_Get_count_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_I32,0)
    writeI32 oprot _v
    writeFieldEnd oprot}
  case f_Get_count_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Get_count_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Get_count_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_count_result_fields iprot record = do
  (_,_t278,_id279) <- readFieldBegin iprot
  if _t278 == T_STOP then return record else
    case _id279 of 
      0 -> if _t278 == T_I32 then do
        s <- readI32 iprot
        read_Get_count_result_fields iprot record{f_Get_count_result_success=Just s}
        else do
          skip iprot _t278
          read_Get_count_result_fields iprot record
      1 -> if _t278 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Get_count_result_fields iprot record{f_Get_count_result_ire=Just s}
        else do
          skip iprot _t278
          read_Get_count_result_fields iprot record
      2 -> if _t278 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Get_count_result_fields iprot record{f_Get_count_result_ue=Just s}
        else do
          skip iprot _t278
          read_Get_count_result_fields iprot record
      3 -> if _t278 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Get_count_result_fields iprot record{f_Get_count_result_te=Just s}
        else do
          skip iprot _t278
          read_Get_count_result_fields iprot record
      _ -> do
        skip iprot _t278
        readFieldEnd iprot
        read_Get_count_result_fields iprot record
read_Get_count_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_count_result_fields iprot (Get_count_result{f_Get_count_result_success=Nothing,f_Get_count_result_ire=Nothing,f_Get_count_result_ue=Nothing,f_Get_count_result_te=Nothing})
  readStructEnd iprot
  return record
data Multiget_slice_args = Multiget_slice_args{f_Multiget_slice_args_keys :: Maybe [ByteString],f_Multiget_slice_args_column_parent :: Maybe ColumnParent,f_Multiget_slice_args_predicate :: Maybe SlicePredicate,f_Multiget_slice_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Multiget_slice_args oprot record = do
  writeStructBegin oprot "Multiget_slice_args"
  case f_Multiget_slice_args_keys record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keys",T_LIST,1)
    (let {f [] = return (); f (_viter282:t) = do {writeBinary oprot _viter282;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Multiget_slice_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Multiget_slice_args_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("predicate",T_STRUCT,3)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Multiget_slice_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Multiget_slice_args_fields iprot record = do
  (_,_t284,_id285) <- readFieldBegin iprot
  if _t284 == T_STOP then return record else
    case _id285 of 
      1 -> if _t284 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- readBinary iprot;r <- f (n-1); return $ v:r}} in do {(_etype289,_size286) <- readListBegin iprot; f _size286})
        read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_keys=Just s}
        else do
          skip iprot _t284
          read_Multiget_slice_args_fields iprot record
      2 -> if _t284 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_column_parent=Just s}
        else do
          skip iprot _t284
          read_Multiget_slice_args_fields iprot record
      3 -> if _t284 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_predicate=Just s}
        else do
          skip iprot _t284
          read_Multiget_slice_args_fields iprot record
      4 -> if _t284 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_consistency_level=Just s}
        else do
          skip iprot _t284
          read_Multiget_slice_args_fields iprot record
      _ -> do
        skip iprot _t284
        readFieldEnd iprot
        read_Multiget_slice_args_fields iprot record
read_Multiget_slice_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Multiget_slice_args_fields iprot (Multiget_slice_args{f_Multiget_slice_args_keys=Nothing,f_Multiget_slice_args_column_parent=Nothing,f_Multiget_slice_args_predicate=Nothing,f_Multiget_slice_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Multiget_slice_result = Multiget_slice_result{f_Multiget_slice_result_success :: Maybe (Map.Map ByteString [ColumnOrSuperColumn]),f_Multiget_slice_result_ire :: Maybe InvalidRequestException,f_Multiget_slice_result_ue :: Maybe UnavailableException,f_Multiget_slice_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Multiget_slice_result oprot record = do
  writeStructBegin oprot "Multiget_slice_result"
  case f_Multiget_slice_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_MAP,0)
    (let {f [] = return (); f ((_kiter293,_viter294):t) = do {do {writeBinary oprot _kiter293;(let {f [] = return (); f (_viter295:t) = do {write_ColumnOrSuperColumn oprot _viter295;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _viter294); f _viter294;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
    writeFieldEnd oprot}
  case f_Multiget_slice_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Multiget_slice_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Multiget_slice_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Multiget_slice_result_fields iprot record = do
  (_,_t297,_id298) <- readFieldBegin iprot
  if _t297 == T_STOP then return record else
    case _id298 of 
      0 -> if _t297 == T_MAP then do
        s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- (let {f 0 = return []; f n = do {v <- (read_ColumnOrSuperColumn iprot);r <- f (n-1); return $ v:r}} in do {(_etype307,_size304) <- readListBegin iprot; f _size304});r <- f (n-1); return $ (k,v):r}} in do {(_ktype300,_vtype301,_size299) <- readMapBegin iprot; l <- f _size299; return $ Map.fromList l})
        read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_success=Just s}
        else do
          skip iprot _t297
          read_Multiget_slice_result_fields iprot record
      1 -> if _t297 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_ire=Just s}
        else do
          skip iprot _t297
          read_Multiget_slice_result_fields iprot record
      2 -> if _t297 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_ue=Just s}
        else do
          skip iprot _t297
          read_Multiget_slice_result_fields iprot record
      3 -> if _t297 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_te=Just s}
        else do
          skip iprot _t297
          read_Multiget_slice_result_fields iprot record
      _ -> do
        skip iprot _t297
        readFieldEnd iprot
        read_Multiget_slice_result_fields iprot record
read_Multiget_slice_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Multiget_slice_result_fields iprot (Multiget_slice_result{f_Multiget_slice_result_success=Nothing,f_Multiget_slice_result_ire=Nothing,f_Multiget_slice_result_ue=Nothing,f_Multiget_slice_result_te=Nothing})
  readStructEnd iprot
  return record
data Multiget_count_args = Multiget_count_args{f_Multiget_count_args_keys :: Maybe [ByteString],f_Multiget_count_args_column_parent :: Maybe ColumnParent,f_Multiget_count_args_predicate :: Maybe SlicePredicate,f_Multiget_count_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Multiget_count_args oprot record = do
  writeStructBegin oprot "Multiget_count_args"
  case f_Multiget_count_args_keys record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keys",T_LIST,1)
    (let {f [] = return (); f (_viter311:t) = do {writeBinary oprot _viter311;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Multiget_count_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Multiget_count_args_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("predicate",T_STRUCT,3)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Multiget_count_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Multiget_count_args_fields iprot record = do
  (_,_t313,_id314) <- readFieldBegin iprot
  if _t313 == T_STOP then return record else
    case _id314 of 
      1 -> if _t313 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- readBinary iprot;r <- f (n-1); return $ v:r}} in do {(_etype318,_size315) <- readListBegin iprot; f _size315})
        read_Multiget_count_args_fields iprot record{f_Multiget_count_args_keys=Just s}
        else do
          skip iprot _t313
          read_Multiget_count_args_fields iprot record
      2 -> if _t313 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Multiget_count_args_fields iprot record{f_Multiget_count_args_column_parent=Just s}
        else do
          skip iprot _t313
          read_Multiget_count_args_fields iprot record
      3 -> if _t313 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Multiget_count_args_fields iprot record{f_Multiget_count_args_predicate=Just s}
        else do
          skip iprot _t313
          read_Multiget_count_args_fields iprot record
      4 -> if _t313 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Multiget_count_args_fields iprot record{f_Multiget_count_args_consistency_level=Just s}
        else do
          skip iprot _t313
          read_Multiget_count_args_fields iprot record
      _ -> do
        skip iprot _t313
        readFieldEnd iprot
        read_Multiget_count_args_fields iprot record
read_Multiget_count_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Multiget_count_args_fields iprot (Multiget_count_args{f_Multiget_count_args_keys=Nothing,f_Multiget_count_args_column_parent=Nothing,f_Multiget_count_args_predicate=Nothing,f_Multiget_count_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Multiget_count_result = Multiget_count_result{f_Multiget_count_result_success :: Maybe (Map.Map ByteString Int32),f_Multiget_count_result_ire :: Maybe InvalidRequestException,f_Multiget_count_result_ue :: Maybe UnavailableException,f_Multiget_count_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Multiget_count_result oprot record = do
  writeStructBegin oprot "Multiget_count_result"
  case f_Multiget_count_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_MAP,0)
    (let {f [] = return (); f ((_kiter322,_viter323):t) = do {do {writeBinary oprot _kiter322;writeI32 oprot _viter323};f t}} in do {writeMapBegin oprot (T_STRING,T_I32,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
    writeFieldEnd oprot}
  case f_Multiget_count_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Multiget_count_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Multiget_count_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Multiget_count_result_fields iprot record = do
  (_,_t325,_id326) <- readFieldBegin iprot
  if _t325 == T_STOP then return record else
    case _id326 of 
      0 -> if _t325 == T_MAP then do
        s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- readI32 iprot;r <- f (n-1); return $ (k,v):r}} in do {(_ktype328,_vtype329,_size327) <- readMapBegin iprot; l <- f _size327; return $ Map.fromList l})
        read_Multiget_count_result_fields iprot record{f_Multiget_count_result_success=Just s}
        else do
          skip iprot _t325
          read_Multiget_count_result_fields iprot record
      1 -> if _t325 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Multiget_count_result_fields iprot record{f_Multiget_count_result_ire=Just s}
        else do
          skip iprot _t325
          read_Multiget_count_result_fields iprot record
      2 -> if _t325 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Multiget_count_result_fields iprot record{f_Multiget_count_result_ue=Just s}
        else do
          skip iprot _t325
          read_Multiget_count_result_fields iprot record
      3 -> if _t325 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Multiget_count_result_fields iprot record{f_Multiget_count_result_te=Just s}
        else do
          skip iprot _t325
          read_Multiget_count_result_fields iprot record
      _ -> do
        skip iprot _t325
        readFieldEnd iprot
        read_Multiget_count_result_fields iprot record
read_Multiget_count_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Multiget_count_result_fields iprot (Multiget_count_result{f_Multiget_count_result_success=Nothing,f_Multiget_count_result_ire=Nothing,f_Multiget_count_result_ue=Nothing,f_Multiget_count_result_te=Nothing})
  readStructEnd iprot
  return record
data Get_range_slices_args = Get_range_slices_args{f_Get_range_slices_args_column_parent :: Maybe ColumnParent,f_Get_range_slices_args_predicate :: Maybe SlicePredicate,f_Get_range_slices_args_range :: Maybe KeyRange,f_Get_range_slices_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_range_slices_args oprot record = do
  writeStructBegin oprot "Get_range_slices_args"
  case f_Get_range_slices_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,1)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Get_range_slices_args_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("predicate",T_STRUCT,2)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Get_range_slices_args_range record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("range",T_STRUCT,3)
    write_KeyRange oprot _v
    writeFieldEnd oprot}
  case f_Get_range_slices_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_range_slices_args_fields iprot record = do
  (_,_t335,_id336) <- readFieldBegin iprot
  if _t335 == T_STOP then return record else
    case _id336 of 
      1 -> if _t335 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_column_parent=Just s}
        else do
          skip iprot _t335
          read_Get_range_slices_args_fields iprot record
      2 -> if _t335 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_predicate=Just s}
        else do
          skip iprot _t335
          read_Get_range_slices_args_fields iprot record
      3 -> if _t335 == T_STRUCT then do
        s <- (read_KeyRange iprot)
        read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_range=Just s}
        else do
          skip iprot _t335
          read_Get_range_slices_args_fields iprot record
      4 -> if _t335 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_consistency_level=Just s}
        else do
          skip iprot _t335
          read_Get_range_slices_args_fields iprot record
      _ -> do
        skip iprot _t335
        readFieldEnd iprot
        read_Get_range_slices_args_fields iprot record
read_Get_range_slices_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_range_slices_args_fields iprot (Get_range_slices_args{f_Get_range_slices_args_column_parent=Nothing,f_Get_range_slices_args_predicate=Nothing,f_Get_range_slices_args_range=Nothing,f_Get_range_slices_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Get_range_slices_result = Get_range_slices_result{f_Get_range_slices_result_success :: Maybe [KeySlice],f_Get_range_slices_result_ire :: Maybe InvalidRequestException,f_Get_range_slices_result_ue :: Maybe UnavailableException,f_Get_range_slices_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_range_slices_result oprot record = do
  writeStructBegin oprot "Get_range_slices_result"
  case f_Get_range_slices_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter339:t) = do {write_KeySlice oprot _viter339;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Get_range_slices_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Get_range_slices_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Get_range_slices_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_range_slices_result_fields iprot record = do
  (_,_t341,_id342) <- readFieldBegin iprot
  if _t341 == T_STOP then return record else
    case _id342 of 
      0 -> if _t341 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- (read_KeySlice iprot);r <- f (n-1); return $ v:r}} in do {(_etype346,_size343) <- readListBegin iprot; f _size343})
        read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_success=Just s}
        else do
          skip iprot _t341
          read_Get_range_slices_result_fields iprot record
      1 -> if _t341 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_ire=Just s}
        else do
          skip iprot _t341
          read_Get_range_slices_result_fields iprot record
      2 -> if _t341 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_ue=Just s}
        else do
          skip iprot _t341
          read_Get_range_slices_result_fields iprot record
      3 -> if _t341 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_te=Just s}
        else do
          skip iprot _t341
          read_Get_range_slices_result_fields iprot record
      _ -> do
        skip iprot _t341
        readFieldEnd iprot
        read_Get_range_slices_result_fields iprot record
read_Get_range_slices_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_range_slices_result_fields iprot (Get_range_slices_result{f_Get_range_slices_result_success=Nothing,f_Get_range_slices_result_ire=Nothing,f_Get_range_slices_result_ue=Nothing,f_Get_range_slices_result_te=Nothing})
  readStructEnd iprot
  return record
data Get_indexed_slices_args = Get_indexed_slices_args{f_Get_indexed_slices_args_column_parent :: Maybe ColumnParent,f_Get_indexed_slices_args_index_clause :: Maybe IndexClause,f_Get_indexed_slices_args_column_predicate :: Maybe SlicePredicate,f_Get_indexed_slices_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_indexed_slices_args oprot record = do
  writeStructBegin oprot "Get_indexed_slices_args"
  case f_Get_indexed_slices_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,1)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Get_indexed_slices_args_index_clause record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("index_clause",T_STRUCT,2)
    write_IndexClause oprot _v
    writeFieldEnd oprot}
  case f_Get_indexed_slices_args_column_predicate record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_predicate",T_STRUCT,3)
    write_SlicePredicate oprot _v
    writeFieldEnd oprot}
  case f_Get_indexed_slices_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_indexed_slices_args_fields iprot record = do
  (_,_t351,_id352) <- readFieldBegin iprot
  if _t351 == T_STOP then return record else
    case _id352 of 
      1 -> if _t351 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_column_parent=Just s}
        else do
          skip iprot _t351
          read_Get_indexed_slices_args_fields iprot record
      2 -> if _t351 == T_STRUCT then do
        s <- (read_IndexClause iprot)
        read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_index_clause=Just s}
        else do
          skip iprot _t351
          read_Get_indexed_slices_args_fields iprot record
      3 -> if _t351 == T_STRUCT then do
        s <- (read_SlicePredicate iprot)
        read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_column_predicate=Just s}
        else do
          skip iprot _t351
          read_Get_indexed_slices_args_fields iprot record
      4 -> if _t351 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_consistency_level=Just s}
        else do
          skip iprot _t351
          read_Get_indexed_slices_args_fields iprot record
      _ -> do
        skip iprot _t351
        readFieldEnd iprot
        read_Get_indexed_slices_args_fields iprot record
read_Get_indexed_slices_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_indexed_slices_args_fields iprot (Get_indexed_slices_args{f_Get_indexed_slices_args_column_parent=Nothing,f_Get_indexed_slices_args_index_clause=Nothing,f_Get_indexed_slices_args_column_predicate=Nothing,f_Get_indexed_slices_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Get_indexed_slices_result = Get_indexed_slices_result{f_Get_indexed_slices_result_success :: Maybe [KeySlice],f_Get_indexed_slices_result_ire :: Maybe InvalidRequestException,f_Get_indexed_slices_result_ue :: Maybe UnavailableException,f_Get_indexed_slices_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_indexed_slices_result oprot record = do
  writeStructBegin oprot "Get_indexed_slices_result"
  case f_Get_indexed_slices_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter355:t) = do {write_KeySlice oprot _viter355;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Get_indexed_slices_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Get_indexed_slices_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Get_indexed_slices_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Get_indexed_slices_result_fields iprot record = do
  (_,_t357,_id358) <- readFieldBegin iprot
  if _t357 == T_STOP then return record else
    case _id358 of 
      0 -> if _t357 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- (read_KeySlice iprot);r <- f (n-1); return $ v:r}} in do {(_etype362,_size359) <- readListBegin iprot; f _size359})
        read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_success=Just s}
        else do
          skip iprot _t357
          read_Get_indexed_slices_result_fields iprot record
      1 -> if _t357 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_ire=Just s}
        else do
          skip iprot _t357
          read_Get_indexed_slices_result_fields iprot record
      2 -> if _t357 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_ue=Just s}
        else do
          skip iprot _t357
          read_Get_indexed_slices_result_fields iprot record
      3 -> if _t357 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_te=Just s}
        else do
          skip iprot _t357
          read_Get_indexed_slices_result_fields iprot record
      _ -> do
        skip iprot _t357
        readFieldEnd iprot
        read_Get_indexed_slices_result_fields iprot record
read_Get_indexed_slices_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Get_indexed_slices_result_fields iprot (Get_indexed_slices_result{f_Get_indexed_slices_result_success=Nothing,f_Get_indexed_slices_result_ire=Nothing,f_Get_indexed_slices_result_ue=Nothing,f_Get_indexed_slices_result_te=Nothing})
  readStructEnd iprot
  return record
data Insert_args = Insert_args{f_Insert_args_key :: Maybe ByteString,f_Insert_args_column_parent :: Maybe ColumnParent,f_Insert_args_column :: Maybe Column,f_Insert_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Insert_args oprot record = do
  writeStructBegin oprot "Insert_args"
  case f_Insert_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Insert_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Insert_args_column record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column",T_STRUCT,3)
    write_Column oprot _v
    writeFieldEnd oprot}
  case f_Insert_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Insert_args_fields iprot record = do
  (_,_t367,_id368) <- readFieldBegin iprot
  if _t367 == T_STOP then return record else
    case _id368 of 
      1 -> if _t367 == T_STRING then do
        s <- readBinary iprot
        read_Insert_args_fields iprot record{f_Insert_args_key=Just s}
        else do
          skip iprot _t367
          read_Insert_args_fields iprot record
      2 -> if _t367 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Insert_args_fields iprot record{f_Insert_args_column_parent=Just s}
        else do
          skip iprot _t367
          read_Insert_args_fields iprot record
      3 -> if _t367 == T_STRUCT then do
        s <- (read_Column iprot)
        read_Insert_args_fields iprot record{f_Insert_args_column=Just s}
        else do
          skip iprot _t367
          read_Insert_args_fields iprot record
      4 -> if _t367 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Insert_args_fields iprot record{f_Insert_args_consistency_level=Just s}
        else do
          skip iprot _t367
          read_Insert_args_fields iprot record
      _ -> do
        skip iprot _t367
        readFieldEnd iprot
        read_Insert_args_fields iprot record
read_Insert_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Insert_args_fields iprot (Insert_args{f_Insert_args_key=Nothing,f_Insert_args_column_parent=Nothing,f_Insert_args_column=Nothing,f_Insert_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Insert_result = Insert_result{f_Insert_result_ire :: Maybe InvalidRequestException,f_Insert_result_ue :: Maybe UnavailableException,f_Insert_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Insert_result oprot record = do
  writeStructBegin oprot "Insert_result"
  case f_Insert_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Insert_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Insert_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Insert_result_fields iprot record = do
  (_,_t372,_id373) <- readFieldBegin iprot
  if _t372 == T_STOP then return record else
    case _id373 of 
      1 -> if _t372 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Insert_result_fields iprot record{f_Insert_result_ire=Just s}
        else do
          skip iprot _t372
          read_Insert_result_fields iprot record
      2 -> if _t372 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Insert_result_fields iprot record{f_Insert_result_ue=Just s}
        else do
          skip iprot _t372
          read_Insert_result_fields iprot record
      3 -> if _t372 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Insert_result_fields iprot record{f_Insert_result_te=Just s}
        else do
          skip iprot _t372
          read_Insert_result_fields iprot record
      _ -> do
        skip iprot _t372
        readFieldEnd iprot
        read_Insert_result_fields iprot record
read_Insert_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Insert_result_fields iprot (Insert_result{f_Insert_result_ire=Nothing,f_Insert_result_ue=Nothing,f_Insert_result_te=Nothing})
  readStructEnd iprot
  return record
data Add_args = Add_args{f_Add_args_key :: Maybe ByteString,f_Add_args_column_parent :: Maybe ColumnParent,f_Add_args_column :: Maybe CounterColumn,f_Add_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Add_args oprot record = do
  writeStructBegin oprot "Add_args"
  case f_Add_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Add_args_column_parent record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_parent",T_STRUCT,2)
    write_ColumnParent oprot _v
    writeFieldEnd oprot}
  case f_Add_args_column record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column",T_STRUCT,3)
    write_CounterColumn oprot _v
    writeFieldEnd oprot}
  case f_Add_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Add_args_fields iprot record = do
  (_,_t377,_id378) <- readFieldBegin iprot
  if _t377 == T_STOP then return record else
    case _id378 of 
      1 -> if _t377 == T_STRING then do
        s <- readBinary iprot
        read_Add_args_fields iprot record{f_Add_args_key=Just s}
        else do
          skip iprot _t377
          read_Add_args_fields iprot record
      2 -> if _t377 == T_STRUCT then do
        s <- (read_ColumnParent iprot)
        read_Add_args_fields iprot record{f_Add_args_column_parent=Just s}
        else do
          skip iprot _t377
          read_Add_args_fields iprot record
      3 -> if _t377 == T_STRUCT then do
        s <- (read_CounterColumn iprot)
        read_Add_args_fields iprot record{f_Add_args_column=Just s}
        else do
          skip iprot _t377
          read_Add_args_fields iprot record
      4 -> if _t377 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Add_args_fields iprot record{f_Add_args_consistency_level=Just s}
        else do
          skip iprot _t377
          read_Add_args_fields iprot record
      _ -> do
        skip iprot _t377
        readFieldEnd iprot
        read_Add_args_fields iprot record
read_Add_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Add_args_fields iprot (Add_args{f_Add_args_key=Nothing,f_Add_args_column_parent=Nothing,f_Add_args_column=Nothing,f_Add_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Add_result = Add_result{f_Add_result_ire :: Maybe InvalidRequestException,f_Add_result_ue :: Maybe UnavailableException,f_Add_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Add_result oprot record = do
  writeStructBegin oprot "Add_result"
  case f_Add_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Add_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Add_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Add_result_fields iprot record = do
  (_,_t382,_id383) <- readFieldBegin iprot
  if _t382 == T_STOP then return record else
    case _id383 of 
      1 -> if _t382 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Add_result_fields iprot record{f_Add_result_ire=Just s}
        else do
          skip iprot _t382
          read_Add_result_fields iprot record
      2 -> if _t382 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Add_result_fields iprot record{f_Add_result_ue=Just s}
        else do
          skip iprot _t382
          read_Add_result_fields iprot record
      3 -> if _t382 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Add_result_fields iprot record{f_Add_result_te=Just s}
        else do
          skip iprot _t382
          read_Add_result_fields iprot record
      _ -> do
        skip iprot _t382
        readFieldEnd iprot
        read_Add_result_fields iprot record
read_Add_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Add_result_fields iprot (Add_result{f_Add_result_ire=Nothing,f_Add_result_ue=Nothing,f_Add_result_te=Nothing})
  readStructEnd iprot
  return record
data Remove_args = Remove_args{f_Remove_args_key :: Maybe ByteString,f_Remove_args_column_path :: Maybe ColumnPath,f_Remove_args_timestamp :: Maybe Int64,f_Remove_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Remove_args oprot record = do
  writeStructBegin oprot "Remove_args"
  case f_Remove_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Remove_args_column_path record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_path",T_STRUCT,2)
    write_ColumnPath oprot _v
    writeFieldEnd oprot}
  case f_Remove_args_timestamp record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("timestamp",T_I64,3)
    writeI64 oprot _v
    writeFieldEnd oprot}
  case f_Remove_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,4)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Remove_args_fields iprot record = do
  (_,_t387,_id388) <- readFieldBegin iprot
  if _t387 == T_STOP then return record else
    case _id388 of 
      1 -> if _t387 == T_STRING then do
        s <- readBinary iprot
        read_Remove_args_fields iprot record{f_Remove_args_key=Just s}
        else do
          skip iprot _t387
          read_Remove_args_fields iprot record
      2 -> if _t387 == T_STRUCT then do
        s <- (read_ColumnPath iprot)
        read_Remove_args_fields iprot record{f_Remove_args_column_path=Just s}
        else do
          skip iprot _t387
          read_Remove_args_fields iprot record
      3 -> if _t387 == T_I64 then do
        s <- readI64 iprot
        read_Remove_args_fields iprot record{f_Remove_args_timestamp=Just s}
        else do
          skip iprot _t387
          read_Remove_args_fields iprot record
      4 -> if _t387 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Remove_args_fields iprot record{f_Remove_args_consistency_level=Just s}
        else do
          skip iprot _t387
          read_Remove_args_fields iprot record
      _ -> do
        skip iprot _t387
        readFieldEnd iprot
        read_Remove_args_fields iprot record
read_Remove_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Remove_args_fields iprot (Remove_args{f_Remove_args_key=Nothing,f_Remove_args_column_path=Nothing,f_Remove_args_timestamp=Nothing,f_Remove_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Remove_result = Remove_result{f_Remove_result_ire :: Maybe InvalidRequestException,f_Remove_result_ue :: Maybe UnavailableException,f_Remove_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Remove_result oprot record = do
  writeStructBegin oprot "Remove_result"
  case f_Remove_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Remove_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Remove_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Remove_result_fields iprot record = do
  (_,_t392,_id393) <- readFieldBegin iprot
  if _t392 == T_STOP then return record else
    case _id393 of 
      1 -> if _t392 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Remove_result_fields iprot record{f_Remove_result_ire=Just s}
        else do
          skip iprot _t392
          read_Remove_result_fields iprot record
      2 -> if _t392 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Remove_result_fields iprot record{f_Remove_result_ue=Just s}
        else do
          skip iprot _t392
          read_Remove_result_fields iprot record
      3 -> if _t392 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Remove_result_fields iprot record{f_Remove_result_te=Just s}
        else do
          skip iprot _t392
          read_Remove_result_fields iprot record
      _ -> do
        skip iprot _t392
        readFieldEnd iprot
        read_Remove_result_fields iprot record
read_Remove_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Remove_result_fields iprot (Remove_result{f_Remove_result_ire=Nothing,f_Remove_result_ue=Nothing,f_Remove_result_te=Nothing})
  readStructEnd iprot
  return record
data Remove_counter_args = Remove_counter_args{f_Remove_counter_args_key :: Maybe ByteString,f_Remove_counter_args_path :: Maybe ColumnPath,f_Remove_counter_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Remove_counter_args oprot record = do
  writeStructBegin oprot "Remove_counter_args"
  case f_Remove_counter_args_key record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("key",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Remove_counter_args_path record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("path",T_STRUCT,2)
    write_ColumnPath oprot _v
    writeFieldEnd oprot}
  case f_Remove_counter_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,3)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Remove_counter_args_fields iprot record = do
  (_,_t397,_id398) <- readFieldBegin iprot
  if _t397 == T_STOP then return record else
    case _id398 of 
      1 -> if _t397 == T_STRING then do
        s <- readBinary iprot
        read_Remove_counter_args_fields iprot record{f_Remove_counter_args_key=Just s}
        else do
          skip iprot _t397
          read_Remove_counter_args_fields iprot record
      2 -> if _t397 == T_STRUCT then do
        s <- (read_ColumnPath iprot)
        read_Remove_counter_args_fields iprot record{f_Remove_counter_args_path=Just s}
        else do
          skip iprot _t397
          read_Remove_counter_args_fields iprot record
      3 -> if _t397 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Remove_counter_args_fields iprot record{f_Remove_counter_args_consistency_level=Just s}
        else do
          skip iprot _t397
          read_Remove_counter_args_fields iprot record
      _ -> do
        skip iprot _t397
        readFieldEnd iprot
        read_Remove_counter_args_fields iprot record
read_Remove_counter_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Remove_counter_args_fields iprot (Remove_counter_args{f_Remove_counter_args_key=Nothing,f_Remove_counter_args_path=Nothing,f_Remove_counter_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Remove_counter_result = Remove_counter_result{f_Remove_counter_result_ire :: Maybe InvalidRequestException,f_Remove_counter_result_ue :: Maybe UnavailableException,f_Remove_counter_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Remove_counter_result oprot record = do
  writeStructBegin oprot "Remove_counter_result"
  case f_Remove_counter_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Remove_counter_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Remove_counter_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Remove_counter_result_fields iprot record = do
  (_,_t402,_id403) <- readFieldBegin iprot
  if _t402 == T_STOP then return record else
    case _id403 of 
      1 -> if _t402 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Remove_counter_result_fields iprot record{f_Remove_counter_result_ire=Just s}
        else do
          skip iprot _t402
          read_Remove_counter_result_fields iprot record
      2 -> if _t402 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Remove_counter_result_fields iprot record{f_Remove_counter_result_ue=Just s}
        else do
          skip iprot _t402
          read_Remove_counter_result_fields iprot record
      3 -> if _t402 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Remove_counter_result_fields iprot record{f_Remove_counter_result_te=Just s}
        else do
          skip iprot _t402
          read_Remove_counter_result_fields iprot record
      _ -> do
        skip iprot _t402
        readFieldEnd iprot
        read_Remove_counter_result_fields iprot record
read_Remove_counter_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Remove_counter_result_fields iprot (Remove_counter_result{f_Remove_counter_result_ire=Nothing,f_Remove_counter_result_ue=Nothing,f_Remove_counter_result_te=Nothing})
  readStructEnd iprot
  return record
data Batch_mutate_args = Batch_mutate_args{f_Batch_mutate_args_mutation_map :: Maybe (Map.Map ByteString (Map.Map String [Mutation])),f_Batch_mutate_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Batch_mutate_args oprot record = do
  writeStructBegin oprot "Batch_mutate_args"
  case f_Batch_mutate_args_mutation_map record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("mutation_map",T_MAP,1)
    (let {f [] = return (); f ((_kiter406,_viter407):t) = do {do {writeBinary oprot _kiter406;(let {f [] = return (); f ((_kiter408,_viter409):t) = do {do {writeString oprot _kiter408;(let {f [] = return (); f (_viter410:t) = do {write_Mutation oprot _viter410;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _viter409); f _viter409;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _viter407); f (Map.toList _viter407);writeMapEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_MAP,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
    writeFieldEnd oprot}
  case f_Batch_mutate_args_consistency_level record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("consistency_level",T_I32,2)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Batch_mutate_args_fields iprot record = do
  (_,_t412,_id413) <- readFieldBegin iprot
  if _t412 == T_STOP then return record else
    case _id413 of 
      1 -> if _t412 == T_MAP then do
        s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- (let {f 0 = return []; f n = do {k <- readString iprot; v <- (let {f 0 = return []; f n = do {v <- (read_Mutation iprot);r <- f (n-1); return $ v:r}} in do {(_etype427,_size424) <- readListBegin iprot; f _size424});r <- f (n-1); return $ (k,v):r}} in do {(_ktype420,_vtype421,_size419) <- readMapBegin iprot; l <- f _size419; return $ Map.fromList l});r <- f (n-1); return $ (k,v):r}} in do {(_ktype415,_vtype416,_size414) <- readMapBegin iprot; l <- f _size414; return $ Map.fromList l})
        read_Batch_mutate_args_fields iprot record{f_Batch_mutate_args_mutation_map=Just s}
        else do
          skip iprot _t412
          read_Batch_mutate_args_fields iprot record
      2 -> if _t412 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Batch_mutate_args_fields iprot record{f_Batch_mutate_args_consistency_level=Just s}
        else do
          skip iprot _t412
          read_Batch_mutate_args_fields iprot record
      _ -> do
        skip iprot _t412
        readFieldEnd iprot
        read_Batch_mutate_args_fields iprot record
read_Batch_mutate_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Batch_mutate_args_fields iprot (Batch_mutate_args{f_Batch_mutate_args_mutation_map=Nothing,f_Batch_mutate_args_consistency_level=Nothing})
  readStructEnd iprot
  return record
data Batch_mutate_result = Batch_mutate_result{f_Batch_mutate_result_ire :: Maybe InvalidRequestException,f_Batch_mutate_result_ue :: Maybe UnavailableException,f_Batch_mutate_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Batch_mutate_result oprot record = do
  writeStructBegin oprot "Batch_mutate_result"
  case f_Batch_mutate_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Batch_mutate_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Batch_mutate_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Batch_mutate_result_fields iprot record = do
  (_,_t432,_id433) <- readFieldBegin iprot
  if _t432 == T_STOP then return record else
    case _id433 of 
      1 -> if _t432 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_ire=Just s}
        else do
          skip iprot _t432
          read_Batch_mutate_result_fields iprot record
      2 -> if _t432 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_ue=Just s}
        else do
          skip iprot _t432
          read_Batch_mutate_result_fields iprot record
      3 -> if _t432 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_te=Just s}
        else do
          skip iprot _t432
          read_Batch_mutate_result_fields iprot record
      _ -> do
        skip iprot _t432
        readFieldEnd iprot
        read_Batch_mutate_result_fields iprot record
read_Batch_mutate_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Batch_mutate_result_fields iprot (Batch_mutate_result{f_Batch_mutate_result_ire=Nothing,f_Batch_mutate_result_ue=Nothing,f_Batch_mutate_result_te=Nothing})
  readStructEnd iprot
  return record
data Truncate_args = Truncate_args{f_Truncate_args_cfname :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Truncate_args oprot record = do
  writeStructBegin oprot "Truncate_args"
  case f_Truncate_args_cfname record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("cfname",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Truncate_args_fields iprot record = do
  (_,_t437,_id438) <- readFieldBegin iprot
  if _t437 == T_STOP then return record else
    case _id438 of 
      1 -> if _t437 == T_STRING then do
        s <- readString iprot
        read_Truncate_args_fields iprot record{f_Truncate_args_cfname=Just s}
        else do
          skip iprot _t437
          read_Truncate_args_fields iprot record
      _ -> do
        skip iprot _t437
        readFieldEnd iprot
        read_Truncate_args_fields iprot record
read_Truncate_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Truncate_args_fields iprot (Truncate_args{f_Truncate_args_cfname=Nothing})
  readStructEnd iprot
  return record
data Truncate_result = Truncate_result{f_Truncate_result_ire :: Maybe InvalidRequestException,f_Truncate_result_ue :: Maybe UnavailableException} deriving (Show,Eq,Ord,Typeable)
write_Truncate_result oprot record = do
  writeStructBegin oprot "Truncate_result"
  case f_Truncate_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Truncate_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Truncate_result_fields iprot record = do
  (_,_t442,_id443) <- readFieldBegin iprot
  if _t442 == T_STOP then return record else
    case _id443 of 
      1 -> if _t442 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Truncate_result_fields iprot record{f_Truncate_result_ire=Just s}
        else do
          skip iprot _t442
          read_Truncate_result_fields iprot record
      2 -> if _t442 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Truncate_result_fields iprot record{f_Truncate_result_ue=Just s}
        else do
          skip iprot _t442
          read_Truncate_result_fields iprot record
      _ -> do
        skip iprot _t442
        readFieldEnd iprot
        read_Truncate_result_fields iprot record
read_Truncate_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Truncate_result_fields iprot (Truncate_result{f_Truncate_result_ire=Nothing,f_Truncate_result_ue=Nothing})
  readStructEnd iprot
  return record
data Describe_schema_versions_args = Describe_schema_versions_args deriving (Show,Eq,Ord,Typeable)
write_Describe_schema_versions_args oprot record = do
  writeStructBegin oprot "Describe_schema_versions_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_schema_versions_args_fields iprot record = do
  (_,_t447,_id448) <- readFieldBegin iprot
  if _t447 == T_STOP then return record else
    case _id448 of 
      _ -> do
        skip iprot _t447
        readFieldEnd iprot
        read_Describe_schema_versions_args_fields iprot record
read_Describe_schema_versions_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_schema_versions_args_fields iprot (Describe_schema_versions_args{})
  readStructEnd iprot
  return record
data Describe_schema_versions_result = Describe_schema_versions_result{f_Describe_schema_versions_result_success :: Maybe (Map.Map String [String]),f_Describe_schema_versions_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_schema_versions_result oprot record = do
  writeStructBegin oprot "Describe_schema_versions_result"
  case f_Describe_schema_versions_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_MAP,0)
    (let {f [] = return (); f ((_kiter451,_viter452):t) = do {do {writeString oprot _kiter451;(let {f [] = return (); f (_viter453:t) = do {writeString oprot _viter453;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _viter452); f _viter452;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
    writeFieldEnd oprot}
  case f_Describe_schema_versions_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_schema_versions_result_fields iprot record = do
  (_,_t455,_id456) <- readFieldBegin iprot
  if _t455 == T_STOP then return record else
    case _id456 of 
      0 -> if _t455 == T_MAP then do
        s <- (let {f 0 = return []; f n = do {k <- readString iprot; v <- (let {f 0 = return []; f n = do {v <- readString iprot;r <- f (n-1); return $ v:r}} in do {(_etype465,_size462) <- readListBegin iprot; f _size462});r <- f (n-1); return $ (k,v):r}} in do {(_ktype458,_vtype459,_size457) <- readMapBegin iprot; l <- f _size457; return $ Map.fromList l})
        read_Describe_schema_versions_result_fields iprot record{f_Describe_schema_versions_result_success=Just s}
        else do
          skip iprot _t455
          read_Describe_schema_versions_result_fields iprot record
      1 -> if _t455 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Describe_schema_versions_result_fields iprot record{f_Describe_schema_versions_result_ire=Just s}
        else do
          skip iprot _t455
          read_Describe_schema_versions_result_fields iprot record
      _ -> do
        skip iprot _t455
        readFieldEnd iprot
        read_Describe_schema_versions_result_fields iprot record
read_Describe_schema_versions_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_schema_versions_result_fields iprot (Describe_schema_versions_result{f_Describe_schema_versions_result_success=Nothing,f_Describe_schema_versions_result_ire=Nothing})
  readStructEnd iprot
  return record
data Describe_keyspaces_args = Describe_keyspaces_args deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspaces_args oprot record = do
  writeStructBegin oprot "Describe_keyspaces_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_keyspaces_args_fields iprot record = do
  (_,_t470,_id471) <- readFieldBegin iprot
  if _t470 == T_STOP then return record else
    case _id471 of 
      _ -> do
        skip iprot _t470
        readFieldEnd iprot
        read_Describe_keyspaces_args_fields iprot record
read_Describe_keyspaces_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_keyspaces_args_fields iprot (Describe_keyspaces_args{})
  readStructEnd iprot
  return record
data Describe_keyspaces_result = Describe_keyspaces_result{f_Describe_keyspaces_result_success :: Maybe [KsDef],f_Describe_keyspaces_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspaces_result oprot record = do
  writeStructBegin oprot "Describe_keyspaces_result"
  case f_Describe_keyspaces_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter474:t) = do {write_KsDef oprot _viter474;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Describe_keyspaces_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_keyspaces_result_fields iprot record = do
  (_,_t476,_id477) <- readFieldBegin iprot
  if _t476 == T_STOP then return record else
    case _id477 of 
      0 -> if _t476 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- (read_KsDef iprot);r <- f (n-1); return $ v:r}} in do {(_etype481,_size478) <- readListBegin iprot; f _size478})
        read_Describe_keyspaces_result_fields iprot record{f_Describe_keyspaces_result_success=Just s}
        else do
          skip iprot _t476
          read_Describe_keyspaces_result_fields iprot record
      1 -> if _t476 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Describe_keyspaces_result_fields iprot record{f_Describe_keyspaces_result_ire=Just s}
        else do
          skip iprot _t476
          read_Describe_keyspaces_result_fields iprot record
      _ -> do
        skip iprot _t476
        readFieldEnd iprot
        read_Describe_keyspaces_result_fields iprot record
read_Describe_keyspaces_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_keyspaces_result_fields iprot (Describe_keyspaces_result{f_Describe_keyspaces_result_success=Nothing,f_Describe_keyspaces_result_ire=Nothing})
  readStructEnd iprot
  return record
data Describe_cluster_name_args = Describe_cluster_name_args deriving (Show,Eq,Ord,Typeable)
write_Describe_cluster_name_args oprot record = do
  writeStructBegin oprot "Describe_cluster_name_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_cluster_name_args_fields iprot record = do
  (_,_t486,_id487) <- readFieldBegin iprot
  if _t486 == T_STOP then return record else
    case _id487 of 
      _ -> do
        skip iprot _t486
        readFieldEnd iprot
        read_Describe_cluster_name_args_fields iprot record
read_Describe_cluster_name_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_cluster_name_args_fields iprot (Describe_cluster_name_args{})
  readStructEnd iprot
  return record
data Describe_cluster_name_result = Describe_cluster_name_result{f_Describe_cluster_name_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_cluster_name_result oprot record = do
  writeStructBegin oprot "Describe_cluster_name_result"
  case f_Describe_cluster_name_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_cluster_name_result_fields iprot record = do
  (_,_t491,_id492) <- readFieldBegin iprot
  if _t491 == T_STOP then return record else
    case _id492 of 
      0 -> if _t491 == T_STRING then do
        s <- readString iprot
        read_Describe_cluster_name_result_fields iprot record{f_Describe_cluster_name_result_success=Just s}
        else do
          skip iprot _t491
          read_Describe_cluster_name_result_fields iprot record
      _ -> do
        skip iprot _t491
        readFieldEnd iprot
        read_Describe_cluster_name_result_fields iprot record
read_Describe_cluster_name_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_cluster_name_result_fields iprot (Describe_cluster_name_result{f_Describe_cluster_name_result_success=Nothing})
  readStructEnd iprot
  return record
data Describe_version_args = Describe_version_args deriving (Show,Eq,Ord,Typeable)
write_Describe_version_args oprot record = do
  writeStructBegin oprot "Describe_version_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_version_args_fields iprot record = do
  (_,_t496,_id497) <- readFieldBegin iprot
  if _t496 == T_STOP then return record else
    case _id497 of 
      _ -> do
        skip iprot _t496
        readFieldEnd iprot
        read_Describe_version_args_fields iprot record
read_Describe_version_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_version_args_fields iprot (Describe_version_args{})
  readStructEnd iprot
  return record
data Describe_version_result = Describe_version_result{f_Describe_version_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_version_result oprot record = do
  writeStructBegin oprot "Describe_version_result"
  case f_Describe_version_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_version_result_fields iprot record = do
  (_,_t501,_id502) <- readFieldBegin iprot
  if _t501 == T_STOP then return record else
    case _id502 of 
      0 -> if _t501 == T_STRING then do
        s <- readString iprot
        read_Describe_version_result_fields iprot record{f_Describe_version_result_success=Just s}
        else do
          skip iprot _t501
          read_Describe_version_result_fields iprot record
      _ -> do
        skip iprot _t501
        readFieldEnd iprot
        read_Describe_version_result_fields iprot record
read_Describe_version_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_version_result_fields iprot (Describe_version_result{f_Describe_version_result_success=Nothing})
  readStructEnd iprot
  return record
data Describe_ring_args = Describe_ring_args{f_Describe_ring_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_ring_args oprot record = do
  writeStructBegin oprot "Describe_ring_args"
  case f_Describe_ring_args_keyspace record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keyspace",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_ring_args_fields iprot record = do
  (_,_t506,_id507) <- readFieldBegin iprot
  if _t506 == T_STOP then return record else
    case _id507 of 
      1 -> if _t506 == T_STRING then do
        s <- readString iprot
        read_Describe_ring_args_fields iprot record{f_Describe_ring_args_keyspace=Just s}
        else do
          skip iprot _t506
          read_Describe_ring_args_fields iprot record
      _ -> do
        skip iprot _t506
        readFieldEnd iprot
        read_Describe_ring_args_fields iprot record
read_Describe_ring_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_ring_args_fields iprot (Describe_ring_args{f_Describe_ring_args_keyspace=Nothing})
  readStructEnd iprot
  return record
data Describe_ring_result = Describe_ring_result{f_Describe_ring_result_success :: Maybe [TokenRange],f_Describe_ring_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_ring_result oprot record = do
  writeStructBegin oprot "Describe_ring_result"
  case f_Describe_ring_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter510:t) = do {write_TokenRange oprot _viter510;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Describe_ring_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_ring_result_fields iprot record = do
  (_,_t512,_id513) <- readFieldBegin iprot
  if _t512 == T_STOP then return record else
    case _id513 of 
      0 -> if _t512 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- (read_TokenRange iprot);r <- f (n-1); return $ v:r}} in do {(_etype517,_size514) <- readListBegin iprot; f _size514})
        read_Describe_ring_result_fields iprot record{f_Describe_ring_result_success=Just s}
        else do
          skip iprot _t512
          read_Describe_ring_result_fields iprot record
      1 -> if _t512 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Describe_ring_result_fields iprot record{f_Describe_ring_result_ire=Just s}
        else do
          skip iprot _t512
          read_Describe_ring_result_fields iprot record
      _ -> do
        skip iprot _t512
        readFieldEnd iprot
        read_Describe_ring_result_fields iprot record
read_Describe_ring_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_ring_result_fields iprot (Describe_ring_result{f_Describe_ring_result_success=Nothing,f_Describe_ring_result_ire=Nothing})
  readStructEnd iprot
  return record
data Describe_partitioner_args = Describe_partitioner_args deriving (Show,Eq,Ord,Typeable)
write_Describe_partitioner_args oprot record = do
  writeStructBegin oprot "Describe_partitioner_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_partitioner_args_fields iprot record = do
  (_,_t522,_id523) <- readFieldBegin iprot
  if _t522 == T_STOP then return record else
    case _id523 of 
      _ -> do
        skip iprot _t522
        readFieldEnd iprot
        read_Describe_partitioner_args_fields iprot record
read_Describe_partitioner_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_partitioner_args_fields iprot (Describe_partitioner_args{})
  readStructEnd iprot
  return record
data Describe_partitioner_result = Describe_partitioner_result{f_Describe_partitioner_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_partitioner_result oprot record = do
  writeStructBegin oprot "Describe_partitioner_result"
  case f_Describe_partitioner_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_partitioner_result_fields iprot record = do
  (_,_t527,_id528) <- readFieldBegin iprot
  if _t527 == T_STOP then return record else
    case _id528 of 
      0 -> if _t527 == T_STRING then do
        s <- readString iprot
        read_Describe_partitioner_result_fields iprot record{f_Describe_partitioner_result_success=Just s}
        else do
          skip iprot _t527
          read_Describe_partitioner_result_fields iprot record
      _ -> do
        skip iprot _t527
        readFieldEnd iprot
        read_Describe_partitioner_result_fields iprot record
read_Describe_partitioner_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_partitioner_result_fields iprot (Describe_partitioner_result{f_Describe_partitioner_result_success=Nothing})
  readStructEnd iprot
  return record
data Describe_snitch_args = Describe_snitch_args deriving (Show,Eq,Ord,Typeable)
write_Describe_snitch_args oprot record = do
  writeStructBegin oprot "Describe_snitch_args"
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_snitch_args_fields iprot record = do
  (_,_t532,_id533) <- readFieldBegin iprot
  if _t532 == T_STOP then return record else
    case _id533 of 
      _ -> do
        skip iprot _t532
        readFieldEnd iprot
        read_Describe_snitch_args_fields iprot record
read_Describe_snitch_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_snitch_args_fields iprot (Describe_snitch_args{})
  readStructEnd iprot
  return record
data Describe_snitch_result = Describe_snitch_result{f_Describe_snitch_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_snitch_result oprot record = do
  writeStructBegin oprot "Describe_snitch_result"
  case f_Describe_snitch_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_snitch_result_fields iprot record = do
  (_,_t537,_id538) <- readFieldBegin iprot
  if _t537 == T_STOP then return record else
    case _id538 of 
      0 -> if _t537 == T_STRING then do
        s <- readString iprot
        read_Describe_snitch_result_fields iprot record{f_Describe_snitch_result_success=Just s}
        else do
          skip iprot _t537
          read_Describe_snitch_result_fields iprot record
      _ -> do
        skip iprot _t537
        readFieldEnd iprot
        read_Describe_snitch_result_fields iprot record
read_Describe_snitch_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_snitch_result_fields iprot (Describe_snitch_result{f_Describe_snitch_result_success=Nothing})
  readStructEnd iprot
  return record
data Describe_keyspace_args = Describe_keyspace_args{f_Describe_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspace_args oprot record = do
  writeStructBegin oprot "Describe_keyspace_args"
  case f_Describe_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keyspace",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_keyspace_args_fields iprot record = do
  (_,_t542,_id543) <- readFieldBegin iprot
  if _t542 == T_STOP then return record else
    case _id543 of 
      1 -> if _t542 == T_STRING then do
        s <- readString iprot
        read_Describe_keyspace_args_fields iprot record{f_Describe_keyspace_args_keyspace=Just s}
        else do
          skip iprot _t542
          read_Describe_keyspace_args_fields iprot record
      _ -> do
        skip iprot _t542
        readFieldEnd iprot
        read_Describe_keyspace_args_fields iprot record
read_Describe_keyspace_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_keyspace_args_fields iprot (Describe_keyspace_args{f_Describe_keyspace_args_keyspace=Nothing})
  readStructEnd iprot
  return record
data Describe_keyspace_result = Describe_keyspace_result{f_Describe_keyspace_result_success :: Maybe KsDef,f_Describe_keyspace_result_nfe :: Maybe NotFoundException,f_Describe_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspace_result oprot record = do
  writeStructBegin oprot "Describe_keyspace_result"
  case f_Describe_keyspace_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRUCT,0)
    write_KsDef oprot _v
    writeFieldEnd oprot}
  case f_Describe_keyspace_result_nfe record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("nfe",T_STRUCT,1)
    write_NotFoundException oprot _v
    writeFieldEnd oprot}
  case f_Describe_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,2)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_keyspace_result_fields iprot record = do
  (_,_t547,_id548) <- readFieldBegin iprot
  if _t547 == T_STOP then return record else
    case _id548 of 
      0 -> if _t547 == T_STRUCT then do
        s <- (read_KsDef iprot)
        read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_success=Just s}
        else do
          skip iprot _t547
          read_Describe_keyspace_result_fields iprot record
      1 -> if _t547 == T_STRUCT then do
        s <- (read_NotFoundException iprot)
        read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_nfe=Just s}
        else do
          skip iprot _t547
          read_Describe_keyspace_result_fields iprot record
      2 -> if _t547 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_ire=Just s}
        else do
          skip iprot _t547
          read_Describe_keyspace_result_fields iprot record
      _ -> do
        skip iprot _t547
        readFieldEnd iprot
        read_Describe_keyspace_result_fields iprot record
read_Describe_keyspace_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_keyspace_result_fields iprot (Describe_keyspace_result{f_Describe_keyspace_result_success=Nothing,f_Describe_keyspace_result_nfe=Nothing,f_Describe_keyspace_result_ire=Nothing})
  readStructEnd iprot
  return record
data Describe_splits_args = Describe_splits_args{f_Describe_splits_args_cfName :: Maybe String,f_Describe_splits_args_start_token :: Maybe String,f_Describe_splits_args_end_token :: Maybe String,f_Describe_splits_args_keys_per_split :: Maybe Int32} deriving (Show,Eq,Ord,Typeable)
write_Describe_splits_args oprot record = do
  writeStructBegin oprot "Describe_splits_args"
  case f_Describe_splits_args_cfName record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("cfName",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_Describe_splits_args_start_token record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("start_token",T_STRING,2)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_Describe_splits_args_end_token record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("end_token",T_STRING,3)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_Describe_splits_args_keys_per_split record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keys_per_split",T_I32,4)
    writeI32 oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_splits_args_fields iprot record = do
  (_,_t552,_id553) <- readFieldBegin iprot
  if _t552 == T_STOP then return record else
    case _id553 of 
      1 -> if _t552 == T_STRING then do
        s <- readString iprot
        read_Describe_splits_args_fields iprot record{f_Describe_splits_args_cfName=Just s}
        else do
          skip iprot _t552
          read_Describe_splits_args_fields iprot record
      2 -> if _t552 == T_STRING then do
        s <- readString iprot
        read_Describe_splits_args_fields iprot record{f_Describe_splits_args_start_token=Just s}
        else do
          skip iprot _t552
          read_Describe_splits_args_fields iprot record
      3 -> if _t552 == T_STRING then do
        s <- readString iprot
        read_Describe_splits_args_fields iprot record{f_Describe_splits_args_end_token=Just s}
        else do
          skip iprot _t552
          read_Describe_splits_args_fields iprot record
      4 -> if _t552 == T_I32 then do
        s <- readI32 iprot
        read_Describe_splits_args_fields iprot record{f_Describe_splits_args_keys_per_split=Just s}
        else do
          skip iprot _t552
          read_Describe_splits_args_fields iprot record
      _ -> do
        skip iprot _t552
        readFieldEnd iprot
        read_Describe_splits_args_fields iprot record
read_Describe_splits_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_splits_args_fields iprot (Describe_splits_args{f_Describe_splits_args_cfName=Nothing,f_Describe_splits_args_start_token=Nothing,f_Describe_splits_args_end_token=Nothing,f_Describe_splits_args_keys_per_split=Nothing})
  readStructEnd iprot
  return record
data Describe_splits_result = Describe_splits_result{f_Describe_splits_result_success :: Maybe [String],f_Describe_splits_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_splits_result oprot record = do
  writeStructBegin oprot "Describe_splits_result"
  case f_Describe_splits_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_LIST,0)
    (let {f [] = return (); f (_viter556:t) = do {writeString oprot _viter556;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
    writeFieldEnd oprot}
  case f_Describe_splits_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Describe_splits_result_fields iprot record = do
  (_,_t558,_id559) <- readFieldBegin iprot
  if _t558 == T_STOP then return record else
    case _id559 of 
      0 -> if _t558 == T_LIST then do
        s <- (let {f 0 = return []; f n = do {v <- readString iprot;r <- f (n-1); return $ v:r}} in do {(_etype563,_size560) <- readListBegin iprot; f _size560})
        read_Describe_splits_result_fields iprot record{f_Describe_splits_result_success=Just s}
        else do
          skip iprot _t558
          read_Describe_splits_result_fields iprot record
      1 -> if _t558 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Describe_splits_result_fields iprot record{f_Describe_splits_result_ire=Just s}
        else do
          skip iprot _t558
          read_Describe_splits_result_fields iprot record
      _ -> do
        skip iprot _t558
        readFieldEnd iprot
        read_Describe_splits_result_fields iprot record
read_Describe_splits_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Describe_splits_result_fields iprot (Describe_splits_result{f_Describe_splits_result_success=Nothing,f_Describe_splits_result_ire=Nothing})
  readStructEnd iprot
  return record
data System_add_column_family_args = System_add_column_family_args{f_System_add_column_family_args_cf_def :: Maybe CfDef} deriving (Show,Eq,Ord,Typeable)
write_System_add_column_family_args oprot record = do
  writeStructBegin oprot "System_add_column_family_args"
  case f_System_add_column_family_args_cf_def record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("cf_def",T_STRUCT,1)
    write_CfDef oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_add_column_family_args_fields iprot record = do
  (_,_t568,_id569) <- readFieldBegin iprot
  if _t568 == T_STOP then return record else
    case _id569 of 
      1 -> if _t568 == T_STRUCT then do
        s <- (read_CfDef iprot)
        read_System_add_column_family_args_fields iprot record{f_System_add_column_family_args_cf_def=Just s}
        else do
          skip iprot _t568
          read_System_add_column_family_args_fields iprot record
      _ -> do
        skip iprot _t568
        readFieldEnd iprot
        read_System_add_column_family_args_fields iprot record
read_System_add_column_family_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_add_column_family_args_fields iprot (System_add_column_family_args{f_System_add_column_family_args_cf_def=Nothing})
  readStructEnd iprot
  return record
data System_add_column_family_result = System_add_column_family_result{f_System_add_column_family_result_success :: Maybe String,f_System_add_column_family_result_ire :: Maybe InvalidRequestException,f_System_add_column_family_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_add_column_family_result oprot record = do
  writeStructBegin oprot "System_add_column_family_result"
  case f_System_add_column_family_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_add_column_family_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_add_column_family_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_add_column_family_result_fields iprot record = do
  (_,_t573,_id574) <- readFieldBegin iprot
  if _t573 == T_STOP then return record else
    case _id574 of 
      0 -> if _t573 == T_STRING then do
        s <- readString iprot
        read_System_add_column_family_result_fields iprot record{f_System_add_column_family_result_success=Just s}
        else do
          skip iprot _t573
          read_System_add_column_family_result_fields iprot record
      1 -> if _t573 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_add_column_family_result_fields iprot record{f_System_add_column_family_result_ire=Just s}
        else do
          skip iprot _t573
          read_System_add_column_family_result_fields iprot record
      2 -> if _t573 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_add_column_family_result_fields iprot record{f_System_add_column_family_result_sde=Just s}
        else do
          skip iprot _t573
          read_System_add_column_family_result_fields iprot record
      _ -> do
        skip iprot _t573
        readFieldEnd iprot
        read_System_add_column_family_result_fields iprot record
read_System_add_column_family_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_add_column_family_result_fields iprot (System_add_column_family_result{f_System_add_column_family_result_success=Nothing,f_System_add_column_family_result_ire=Nothing,f_System_add_column_family_result_sde=Nothing})
  readStructEnd iprot
  return record
data System_drop_column_family_args = System_drop_column_family_args{f_System_drop_column_family_args_column_family :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_System_drop_column_family_args oprot record = do
  writeStructBegin oprot "System_drop_column_family_args"
  case f_System_drop_column_family_args_column_family record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("column_family",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_drop_column_family_args_fields iprot record = do
  (_,_t578,_id579) <- readFieldBegin iprot
  if _t578 == T_STOP then return record else
    case _id579 of 
      1 -> if _t578 == T_STRING then do
        s <- readString iprot
        read_System_drop_column_family_args_fields iprot record{f_System_drop_column_family_args_column_family=Just s}
        else do
          skip iprot _t578
          read_System_drop_column_family_args_fields iprot record
      _ -> do
        skip iprot _t578
        readFieldEnd iprot
        read_System_drop_column_family_args_fields iprot record
read_System_drop_column_family_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_drop_column_family_args_fields iprot (System_drop_column_family_args{f_System_drop_column_family_args_column_family=Nothing})
  readStructEnd iprot
  return record
data System_drop_column_family_result = System_drop_column_family_result{f_System_drop_column_family_result_success :: Maybe String,f_System_drop_column_family_result_ire :: Maybe InvalidRequestException,f_System_drop_column_family_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_drop_column_family_result oprot record = do
  writeStructBegin oprot "System_drop_column_family_result"
  case f_System_drop_column_family_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_drop_column_family_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_drop_column_family_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_drop_column_family_result_fields iprot record = do
  (_,_t583,_id584) <- readFieldBegin iprot
  if _t583 == T_STOP then return record else
    case _id584 of 
      0 -> if _t583 == T_STRING then do
        s <- readString iprot
        read_System_drop_column_family_result_fields iprot record{f_System_drop_column_family_result_success=Just s}
        else do
          skip iprot _t583
          read_System_drop_column_family_result_fields iprot record
      1 -> if _t583 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_drop_column_family_result_fields iprot record{f_System_drop_column_family_result_ire=Just s}
        else do
          skip iprot _t583
          read_System_drop_column_family_result_fields iprot record
      2 -> if _t583 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_drop_column_family_result_fields iprot record{f_System_drop_column_family_result_sde=Just s}
        else do
          skip iprot _t583
          read_System_drop_column_family_result_fields iprot record
      _ -> do
        skip iprot _t583
        readFieldEnd iprot
        read_System_drop_column_family_result_fields iprot record
read_System_drop_column_family_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_drop_column_family_result_fields iprot (System_drop_column_family_result{f_System_drop_column_family_result_success=Nothing,f_System_drop_column_family_result_ire=Nothing,f_System_drop_column_family_result_sde=Nothing})
  readStructEnd iprot
  return record
data System_add_keyspace_args = System_add_keyspace_args{f_System_add_keyspace_args_ks_def :: Maybe KsDef} deriving (Show,Eq,Ord,Typeable)
write_System_add_keyspace_args oprot record = do
  writeStructBegin oprot "System_add_keyspace_args"
  case f_System_add_keyspace_args_ks_def record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ks_def",T_STRUCT,1)
    write_KsDef oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_add_keyspace_args_fields iprot record = do
  (_,_t588,_id589) <- readFieldBegin iprot
  if _t588 == T_STOP then return record else
    case _id589 of 
      1 -> if _t588 == T_STRUCT then do
        s <- (read_KsDef iprot)
        read_System_add_keyspace_args_fields iprot record{f_System_add_keyspace_args_ks_def=Just s}
        else do
          skip iprot _t588
          read_System_add_keyspace_args_fields iprot record
      _ -> do
        skip iprot _t588
        readFieldEnd iprot
        read_System_add_keyspace_args_fields iprot record
read_System_add_keyspace_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_add_keyspace_args_fields iprot (System_add_keyspace_args{f_System_add_keyspace_args_ks_def=Nothing})
  readStructEnd iprot
  return record
data System_add_keyspace_result = System_add_keyspace_result{f_System_add_keyspace_result_success :: Maybe String,f_System_add_keyspace_result_ire :: Maybe InvalidRequestException,f_System_add_keyspace_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_add_keyspace_result oprot record = do
  writeStructBegin oprot "System_add_keyspace_result"
  case f_System_add_keyspace_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_add_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_add_keyspace_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_add_keyspace_result_fields iprot record = do
  (_,_t593,_id594) <- readFieldBegin iprot
  if _t593 == T_STOP then return record else
    case _id594 of 
      0 -> if _t593 == T_STRING then do
        s <- readString iprot
        read_System_add_keyspace_result_fields iprot record{f_System_add_keyspace_result_success=Just s}
        else do
          skip iprot _t593
          read_System_add_keyspace_result_fields iprot record
      1 -> if _t593 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_add_keyspace_result_fields iprot record{f_System_add_keyspace_result_ire=Just s}
        else do
          skip iprot _t593
          read_System_add_keyspace_result_fields iprot record
      2 -> if _t593 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_add_keyspace_result_fields iprot record{f_System_add_keyspace_result_sde=Just s}
        else do
          skip iprot _t593
          read_System_add_keyspace_result_fields iprot record
      _ -> do
        skip iprot _t593
        readFieldEnd iprot
        read_System_add_keyspace_result_fields iprot record
read_System_add_keyspace_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_add_keyspace_result_fields iprot (System_add_keyspace_result{f_System_add_keyspace_result_success=Nothing,f_System_add_keyspace_result_ire=Nothing,f_System_add_keyspace_result_sde=Nothing})
  readStructEnd iprot
  return record
data System_drop_keyspace_args = System_drop_keyspace_args{f_System_drop_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_System_drop_keyspace_args oprot record = do
  writeStructBegin oprot "System_drop_keyspace_args"
  case f_System_drop_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("keyspace",T_STRING,1)
    writeString oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_drop_keyspace_args_fields iprot record = do
  (_,_t598,_id599) <- readFieldBegin iprot
  if _t598 == T_STOP then return record else
    case _id599 of 
      1 -> if _t598 == T_STRING then do
        s <- readString iprot
        read_System_drop_keyspace_args_fields iprot record{f_System_drop_keyspace_args_keyspace=Just s}
        else do
          skip iprot _t598
          read_System_drop_keyspace_args_fields iprot record
      _ -> do
        skip iprot _t598
        readFieldEnd iprot
        read_System_drop_keyspace_args_fields iprot record
read_System_drop_keyspace_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_drop_keyspace_args_fields iprot (System_drop_keyspace_args{f_System_drop_keyspace_args_keyspace=Nothing})
  readStructEnd iprot
  return record
data System_drop_keyspace_result = System_drop_keyspace_result{f_System_drop_keyspace_result_success :: Maybe String,f_System_drop_keyspace_result_ire :: Maybe InvalidRequestException,f_System_drop_keyspace_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_drop_keyspace_result oprot record = do
  writeStructBegin oprot "System_drop_keyspace_result"
  case f_System_drop_keyspace_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_drop_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_drop_keyspace_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_drop_keyspace_result_fields iprot record = do
  (_,_t603,_id604) <- readFieldBegin iprot
  if _t603 == T_STOP then return record else
    case _id604 of 
      0 -> if _t603 == T_STRING then do
        s <- readString iprot
        read_System_drop_keyspace_result_fields iprot record{f_System_drop_keyspace_result_success=Just s}
        else do
          skip iprot _t603
          read_System_drop_keyspace_result_fields iprot record
      1 -> if _t603 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_drop_keyspace_result_fields iprot record{f_System_drop_keyspace_result_ire=Just s}
        else do
          skip iprot _t603
          read_System_drop_keyspace_result_fields iprot record
      2 -> if _t603 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_drop_keyspace_result_fields iprot record{f_System_drop_keyspace_result_sde=Just s}
        else do
          skip iprot _t603
          read_System_drop_keyspace_result_fields iprot record
      _ -> do
        skip iprot _t603
        readFieldEnd iprot
        read_System_drop_keyspace_result_fields iprot record
read_System_drop_keyspace_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_drop_keyspace_result_fields iprot (System_drop_keyspace_result{f_System_drop_keyspace_result_success=Nothing,f_System_drop_keyspace_result_ire=Nothing,f_System_drop_keyspace_result_sde=Nothing})
  readStructEnd iprot
  return record
data System_update_keyspace_args = System_update_keyspace_args{f_System_update_keyspace_args_ks_def :: Maybe KsDef} deriving (Show,Eq,Ord,Typeable)
write_System_update_keyspace_args oprot record = do
  writeStructBegin oprot "System_update_keyspace_args"
  case f_System_update_keyspace_args_ks_def record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ks_def",T_STRUCT,1)
    write_KsDef oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_update_keyspace_args_fields iprot record = do
  (_,_t608,_id609) <- readFieldBegin iprot
  if _t608 == T_STOP then return record else
    case _id609 of 
      1 -> if _t608 == T_STRUCT then do
        s <- (read_KsDef iprot)
        read_System_update_keyspace_args_fields iprot record{f_System_update_keyspace_args_ks_def=Just s}
        else do
          skip iprot _t608
          read_System_update_keyspace_args_fields iprot record
      _ -> do
        skip iprot _t608
        readFieldEnd iprot
        read_System_update_keyspace_args_fields iprot record
read_System_update_keyspace_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_update_keyspace_args_fields iprot (System_update_keyspace_args{f_System_update_keyspace_args_ks_def=Nothing})
  readStructEnd iprot
  return record
data System_update_keyspace_result = System_update_keyspace_result{f_System_update_keyspace_result_success :: Maybe String,f_System_update_keyspace_result_ire :: Maybe InvalidRequestException,f_System_update_keyspace_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_update_keyspace_result oprot record = do
  writeStructBegin oprot "System_update_keyspace_result"
  case f_System_update_keyspace_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_update_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_update_keyspace_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_update_keyspace_result_fields iprot record = do
  (_,_t613,_id614) <- readFieldBegin iprot
  if _t613 == T_STOP then return record else
    case _id614 of 
      0 -> if _t613 == T_STRING then do
        s <- readString iprot
        read_System_update_keyspace_result_fields iprot record{f_System_update_keyspace_result_success=Just s}
        else do
          skip iprot _t613
          read_System_update_keyspace_result_fields iprot record
      1 -> if _t613 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_update_keyspace_result_fields iprot record{f_System_update_keyspace_result_ire=Just s}
        else do
          skip iprot _t613
          read_System_update_keyspace_result_fields iprot record
      2 -> if _t613 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_update_keyspace_result_fields iprot record{f_System_update_keyspace_result_sde=Just s}
        else do
          skip iprot _t613
          read_System_update_keyspace_result_fields iprot record
      _ -> do
        skip iprot _t613
        readFieldEnd iprot
        read_System_update_keyspace_result_fields iprot record
read_System_update_keyspace_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_update_keyspace_result_fields iprot (System_update_keyspace_result{f_System_update_keyspace_result_success=Nothing,f_System_update_keyspace_result_ire=Nothing,f_System_update_keyspace_result_sde=Nothing})
  readStructEnd iprot
  return record
data System_update_column_family_args = System_update_column_family_args{f_System_update_column_family_args_cf_def :: Maybe CfDef} deriving (Show,Eq,Ord,Typeable)
write_System_update_column_family_args oprot record = do
  writeStructBegin oprot "System_update_column_family_args"
  case f_System_update_column_family_args_cf_def record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("cf_def",T_STRUCT,1)
    write_CfDef oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_update_column_family_args_fields iprot record = do
  (_,_t618,_id619) <- readFieldBegin iprot
  if _t618 == T_STOP then return record else
    case _id619 of 
      1 -> if _t618 == T_STRUCT then do
        s <- (read_CfDef iprot)
        read_System_update_column_family_args_fields iprot record{f_System_update_column_family_args_cf_def=Just s}
        else do
          skip iprot _t618
          read_System_update_column_family_args_fields iprot record
      _ -> do
        skip iprot _t618
        readFieldEnd iprot
        read_System_update_column_family_args_fields iprot record
read_System_update_column_family_args iprot = do
  _ <- readStructBegin iprot
  record <- read_System_update_column_family_args_fields iprot (System_update_column_family_args{f_System_update_column_family_args_cf_def=Nothing})
  readStructEnd iprot
  return record
data System_update_column_family_result = System_update_column_family_result{f_System_update_column_family_result_success :: Maybe String,f_System_update_column_family_result_ire :: Maybe InvalidRequestException,f_System_update_column_family_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_System_update_column_family_result oprot record = do
  writeStructBegin oprot "System_update_column_family_result"
  case f_System_update_column_family_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRING,0)
    writeString oprot _v
    writeFieldEnd oprot}
  case f_System_update_column_family_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_System_update_column_family_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,2)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_System_update_column_family_result_fields iprot record = do
  (_,_t623,_id624) <- readFieldBegin iprot
  if _t623 == T_STOP then return record else
    case _id624 of 
      0 -> if _t623 == T_STRING then do
        s <- readString iprot
        read_System_update_column_family_result_fields iprot record{f_System_update_column_family_result_success=Just s}
        else do
          skip iprot _t623
          read_System_update_column_family_result_fields iprot record
      1 -> if _t623 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_System_update_column_family_result_fields iprot record{f_System_update_column_family_result_ire=Just s}
        else do
          skip iprot _t623
          read_System_update_column_family_result_fields iprot record
      2 -> if _t623 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_System_update_column_family_result_fields iprot record{f_System_update_column_family_result_sde=Just s}
        else do
          skip iprot _t623
          read_System_update_column_family_result_fields iprot record
      _ -> do
        skip iprot _t623
        readFieldEnd iprot
        read_System_update_column_family_result_fields iprot record
read_System_update_column_family_result iprot = do
  _ <- readStructBegin iprot
  record <- read_System_update_column_family_result_fields iprot (System_update_column_family_result{f_System_update_column_family_result_success=Nothing,f_System_update_column_family_result_ire=Nothing,f_System_update_column_family_result_sde=Nothing})
  readStructEnd iprot
  return record
data Execute_cql_query_args = Execute_cql_query_args{f_Execute_cql_query_args_query :: Maybe ByteString,f_Execute_cql_query_args_compression :: Maybe Compression} deriving (Show,Eq,Ord,Typeable)
write_Execute_cql_query_args oprot record = do
  writeStructBegin oprot "Execute_cql_query_args"
  case f_Execute_cql_query_args_query record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("query",T_STRING,1)
    writeBinary oprot _v
    writeFieldEnd oprot}
  case f_Execute_cql_query_args_compression record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("compression",T_I32,2)
    writeI32 oprot (fromIntegral $ fromEnum _v)
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Execute_cql_query_args_fields iprot record = do
  (_,_t628,_id629) <- readFieldBegin iprot
  if _t628 == T_STOP then return record else
    case _id629 of 
      1 -> if _t628 == T_STRING then do
        s <- readBinary iprot
        read_Execute_cql_query_args_fields iprot record{f_Execute_cql_query_args_query=Just s}
        else do
          skip iprot _t628
          read_Execute_cql_query_args_fields iprot record
      2 -> if _t628 == T_I32 then do
        s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
        read_Execute_cql_query_args_fields iprot record{f_Execute_cql_query_args_compression=Just s}
        else do
          skip iprot _t628
          read_Execute_cql_query_args_fields iprot record
      _ -> do
        skip iprot _t628
        readFieldEnd iprot
        read_Execute_cql_query_args_fields iprot record
read_Execute_cql_query_args iprot = do
  _ <- readStructBegin iprot
  record <- read_Execute_cql_query_args_fields iprot (Execute_cql_query_args{f_Execute_cql_query_args_query=Nothing,f_Execute_cql_query_args_compression=Nothing})
  readStructEnd iprot
  return record
data Execute_cql_query_result = Execute_cql_query_result{f_Execute_cql_query_result_success :: Maybe CqlResult,f_Execute_cql_query_result_ire :: Maybe InvalidRequestException,f_Execute_cql_query_result_ue :: Maybe UnavailableException,f_Execute_cql_query_result_te :: Maybe TimedOutException,f_Execute_cql_query_result_sde :: Maybe SchemaDisagreementException} deriving (Show,Eq,Ord,Typeable)
write_Execute_cql_query_result oprot record = do
  writeStructBegin oprot "Execute_cql_query_result"
  case f_Execute_cql_query_result_success record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("success",T_STRUCT,0)
    write_CqlResult oprot _v
    writeFieldEnd oprot}
  case f_Execute_cql_query_result_ire record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ire",T_STRUCT,1)
    write_InvalidRequestException oprot _v
    writeFieldEnd oprot}
  case f_Execute_cql_query_result_ue record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("ue",T_STRUCT,2)
    write_UnavailableException oprot _v
    writeFieldEnd oprot}
  case f_Execute_cql_query_result_te record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("te",T_STRUCT,3)
    write_TimedOutException oprot _v
    writeFieldEnd oprot}
  case f_Execute_cql_query_result_sde record of {Nothing -> return (); Just _v -> do
    writeFieldBegin oprot ("sde",T_STRUCT,4)
    write_SchemaDisagreementException oprot _v
    writeFieldEnd oprot}
  writeFieldStop oprot
  writeStructEnd oprot
read_Execute_cql_query_result_fields iprot record = do
  (_,_t633,_id634) <- readFieldBegin iprot
  if _t633 == T_STOP then return record else
    case _id634 of 
      0 -> if _t633 == T_STRUCT then do
        s <- (read_CqlResult iprot)
        read_Execute_cql_query_result_fields iprot record{f_Execute_cql_query_result_success=Just s}
        else do
          skip iprot _t633
          read_Execute_cql_query_result_fields iprot record
      1 -> if _t633 == T_STRUCT then do
        s <- (read_InvalidRequestException iprot)
        read_Execute_cql_query_result_fields iprot record{f_Execute_cql_query_result_ire=Just s}
        else do
          skip iprot _t633
          read_Execute_cql_query_result_fields iprot record
      2 -> if _t633 == T_STRUCT then do
        s <- (read_UnavailableException iprot)
        read_Execute_cql_query_result_fields iprot record{f_Execute_cql_query_result_ue=Just s}
        else do
          skip iprot _t633
          read_Execute_cql_query_result_fields iprot record
      3 -> if _t633 == T_STRUCT then do
        s <- (read_TimedOutException iprot)
        read_Execute_cql_query_result_fields iprot record{f_Execute_cql_query_result_te=Just s}
        else do
          skip iprot _t633
          read_Execute_cql_query_result_fields iprot record
      4 -> if _t633 == T_STRUCT then do
        s <- (read_SchemaDisagreementException iprot)
        read_Execute_cql_query_result_fields iprot record{f_Execute_cql_query_result_sde=Just s}
        else do
          skip iprot _t633
          read_Execute_cql_query_result_fields iprot record
      _ -> do
        skip iprot _t633
        readFieldEnd iprot
        read_Execute_cql_query_result_fields iprot record
read_Execute_cql_query_result iprot = do
  _ <- readStructBegin iprot
  record <- read_Execute_cql_query_result_fields iprot (Execute_cql_query_result{f_Execute_cql_query_result_success=Nothing,f_Execute_cql_query_result_ire=Nothing,f_Execute_cql_query_result_ue=Nothing,f_Execute_cql_query_result_te=Nothing,f_Execute_cql_query_result_sde=Nothing})
  readStructEnd iprot
  return record
process_login (seqid, iprot, oprot, handler) = do
  args <- read_Login_args iprot
  readMessageEnd iprot
  rs <- return (Login_result Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        Iface.login handler (f_Login_args_auth_request args)
        return rs)
      (\e  -> 
        return rs{f_Login_result_authnx =Just e}))
    (\e  -> 
      return rs{f_Login_result_authzx =Just e}))
  writeMessageBegin oprot ("login", M_REPLY, seqid);
  write_Login_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_set_keyspace (seqid, iprot, oprot, handler) = do
  args <- read_Set_keyspace_args iprot
  readMessageEnd iprot
  rs <- return (Set_keyspace_result Nothing)
  res <- (Control.Exception.catch
    (do
      Iface.set_keyspace handler (f_Set_keyspace_args_keyspace args)
      return rs)
    (\e  -> 
      return rs{f_Set_keyspace_result_ire =Just e}))
  writeMessageBegin oprot ("set_keyspace", M_REPLY, seqid);
  write_Set_keyspace_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_get (seqid, iprot, oprot, handler) = do
  args <- read_Get_args iprot
  readMessageEnd iprot
  rs <- return (Get_result Nothing Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (Control.Exception.catch
          (do
            res <- Iface.get handler (f_Get_args_key args) (f_Get_args_column_path args) (f_Get_args_consistency_level args)
            return rs{f_Get_result_success= Just res})
          (\e  -> 
            return rs{f_Get_result_ire =Just e}))
        (\e  -> 
          return rs{f_Get_result_nfe =Just e}))
      (\e  -> 
        return rs{f_Get_result_ue =Just e}))
    (\e  -> 
      return rs{f_Get_result_te =Just e}))
  writeMessageBegin oprot ("get", M_REPLY, seqid);
  write_Get_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_get_slice (seqid, iprot, oprot, handler) = do
  args <- read_Get_slice_args iprot
  readMessageEnd iprot
  rs <- return (Get_slice_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.get_slice handler (f_Get_slice_args_key args) (f_Get_slice_args_column_parent args) (f_Get_slice_args_predicate args) (f_Get_slice_args_consistency_level args)
          return rs{f_Get_slice_result_success= Just res})
        (\e  -> 
          return rs{f_Get_slice_result_ire =Just e}))
      (\e  -> 
        return rs{f_Get_slice_result_ue =Just e}))
    (\e  -> 
      return rs{f_Get_slice_result_te =Just e}))
  writeMessageBegin oprot ("get_slice", M_REPLY, seqid);
  write_Get_slice_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_get_count (seqid, iprot, oprot, handler) = do
  args <- read_Get_count_args iprot
  readMessageEnd iprot
  rs <- return (Get_count_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.get_count handler (f_Get_count_args_key args) (f_Get_count_args_column_parent args) (f_Get_count_args_predicate args) (f_Get_count_args_consistency_level args)
          return rs{f_Get_count_result_success= Just res})
        (\e  -> 
          return rs{f_Get_count_result_ire =Just e}))
      (\e  -> 
        return rs{f_Get_count_result_ue =Just e}))
    (\e  -> 
      return rs{f_Get_count_result_te =Just e}))
  writeMessageBegin oprot ("get_count", M_REPLY, seqid);
  write_Get_count_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_multiget_slice (seqid, iprot, oprot, handler) = do
  args <- read_Multiget_slice_args iprot
  readMessageEnd iprot
  rs <- return (Multiget_slice_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.multiget_slice handler (f_Multiget_slice_args_keys args) (f_Multiget_slice_args_column_parent args) (f_Multiget_slice_args_predicate args) (f_Multiget_slice_args_consistency_level args)
          return rs{f_Multiget_slice_result_success= Just res})
        (\e  -> 
          return rs{f_Multiget_slice_result_ire =Just e}))
      (\e  -> 
        return rs{f_Multiget_slice_result_ue =Just e}))
    (\e  -> 
      return rs{f_Multiget_slice_result_te =Just e}))
  writeMessageBegin oprot ("multiget_slice", M_REPLY, seqid);
  write_Multiget_slice_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_multiget_count (seqid, iprot, oprot, handler) = do
  args <- read_Multiget_count_args iprot
  readMessageEnd iprot
  rs <- return (Multiget_count_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.multiget_count handler (f_Multiget_count_args_keys args) (f_Multiget_count_args_column_parent args) (f_Multiget_count_args_predicate args) (f_Multiget_count_args_consistency_level args)
          return rs{f_Multiget_count_result_success= Just res})
        (\e  -> 
          return rs{f_Multiget_count_result_ire =Just e}))
      (\e  -> 
        return rs{f_Multiget_count_result_ue =Just e}))
    (\e  -> 
      return rs{f_Multiget_count_result_te =Just e}))
  writeMessageBegin oprot ("multiget_count", M_REPLY, seqid);
  write_Multiget_count_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_get_range_slices (seqid, iprot, oprot, handler) = do
  args <- read_Get_range_slices_args iprot
  readMessageEnd iprot
  rs <- return (Get_range_slices_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.get_range_slices handler (f_Get_range_slices_args_column_parent args) (f_Get_range_slices_args_predicate args) (f_Get_range_slices_args_range args) (f_Get_range_slices_args_consistency_level args)
          return rs{f_Get_range_slices_result_success= Just res})
        (\e  -> 
          return rs{f_Get_range_slices_result_ire =Just e}))
      (\e  -> 
        return rs{f_Get_range_slices_result_ue =Just e}))
    (\e  -> 
      return rs{f_Get_range_slices_result_te =Just e}))
  writeMessageBegin oprot ("get_range_slices", M_REPLY, seqid);
  write_Get_range_slices_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_get_indexed_slices (seqid, iprot, oprot, handler) = do
  args <- read_Get_indexed_slices_args iprot
  readMessageEnd iprot
  rs <- return (Get_indexed_slices_result Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          res <- Iface.get_indexed_slices handler (f_Get_indexed_slices_args_column_parent args) (f_Get_indexed_slices_args_index_clause args) (f_Get_indexed_slices_args_column_predicate args) (f_Get_indexed_slices_args_consistency_level args)
          return rs{f_Get_indexed_slices_result_success= Just res})
        (\e  -> 
          return rs{f_Get_indexed_slices_result_ire =Just e}))
      (\e  -> 
        return rs{f_Get_indexed_slices_result_ue =Just e}))
    (\e  -> 
      return rs{f_Get_indexed_slices_result_te =Just e}))
  writeMessageBegin oprot ("get_indexed_slices", M_REPLY, seqid);
  write_Get_indexed_slices_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_insert (seqid, iprot, oprot, handler) = do
  args <- read_Insert_args iprot
  readMessageEnd iprot
  rs <- return (Insert_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          Iface.insert handler (f_Insert_args_key args) (f_Insert_args_column_parent args) (f_Insert_args_column args) (f_Insert_args_consistency_level args)
          return rs)
        (\e  -> 
          return rs{f_Insert_result_ire =Just e}))
      (\e  -> 
        return rs{f_Insert_result_ue =Just e}))
    (\e  -> 
      return rs{f_Insert_result_te =Just e}))
  writeMessageBegin oprot ("insert", M_REPLY, seqid);
  write_Insert_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_add (seqid, iprot, oprot, handler) = do
  args <- read_Add_args iprot
  readMessageEnd iprot
  rs <- return (Add_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          Iface.add handler (f_Add_args_key args) (f_Add_args_column_parent args) (f_Add_args_column args) (f_Add_args_consistency_level args)
          return rs)
        (\e  -> 
          return rs{f_Add_result_ire =Just e}))
      (\e  -> 
        return rs{f_Add_result_ue =Just e}))
    (\e  -> 
      return rs{f_Add_result_te =Just e}))
  writeMessageBegin oprot ("add", M_REPLY, seqid);
  write_Add_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_remove (seqid, iprot, oprot, handler) = do
  args <- read_Remove_args iprot
  readMessageEnd iprot
  rs <- return (Remove_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          Iface.remove handler (f_Remove_args_key args) (f_Remove_args_column_path args) (f_Remove_args_timestamp args) (f_Remove_args_consistency_level args)
          return rs)
        (\e  -> 
          return rs{f_Remove_result_ire =Just e}))
      (\e  -> 
        return rs{f_Remove_result_ue =Just e}))
    (\e  -> 
      return rs{f_Remove_result_te =Just e}))
  writeMessageBegin oprot ("remove", M_REPLY, seqid);
  write_Remove_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_remove_counter (seqid, iprot, oprot, handler) = do
  args <- read_Remove_counter_args iprot
  readMessageEnd iprot
  rs <- return (Remove_counter_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          Iface.remove_counter handler (f_Remove_counter_args_key args) (f_Remove_counter_args_path args) (f_Remove_counter_args_consistency_level args)
          return rs)
        (\e  -> 
          return rs{f_Remove_counter_result_ire =Just e}))
      (\e  -> 
        return rs{f_Remove_counter_result_ue =Just e}))
    (\e  -> 
      return rs{f_Remove_counter_result_te =Just e}))
  writeMessageBegin oprot ("remove_counter", M_REPLY, seqid);
  write_Remove_counter_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_batch_mutate (seqid, iprot, oprot, handler) = do
  args <- read_Batch_mutate_args iprot
  readMessageEnd iprot
  rs <- return (Batch_mutate_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (do
          Iface.batch_mutate handler (f_Batch_mutate_args_mutation_map args) (f_Batch_mutate_args_consistency_level args)
          return rs)
        (\e  -> 
          return rs{f_Batch_mutate_result_ire =Just e}))
      (\e  -> 
        return rs{f_Batch_mutate_result_ue =Just e}))
    (\e  -> 
      return rs{f_Batch_mutate_result_te =Just e}))
  writeMessageBegin oprot ("batch_mutate", M_REPLY, seqid);
  write_Batch_mutate_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_truncate (seqid, iprot, oprot, handler) = do
  args <- read_Truncate_args iprot
  readMessageEnd iprot
  rs <- return (Truncate_result Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        Iface.truncate handler (f_Truncate_args_cfname args)
        return rs)
      (\e  -> 
        return rs{f_Truncate_result_ire =Just e}))
    (\e  -> 
      return rs{f_Truncate_result_ue =Just e}))
  writeMessageBegin oprot ("truncate", M_REPLY, seqid);
  write_Truncate_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_schema_versions (seqid, iprot, oprot, handler) = do
  args <- read_Describe_schema_versions_args iprot
  readMessageEnd iprot
  rs <- return (Describe_schema_versions_result Nothing Nothing)
  res <- (Control.Exception.catch
    (do
      res <- Iface.describe_schema_versions handler
      return rs{f_Describe_schema_versions_result_success= Just res})
    (\e  -> 
      return rs{f_Describe_schema_versions_result_ire =Just e}))
  writeMessageBegin oprot ("describe_schema_versions", M_REPLY, seqid);
  write_Describe_schema_versions_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_keyspaces (seqid, iprot, oprot, handler) = do
  args <- read_Describe_keyspaces_args iprot
  readMessageEnd iprot
  rs <- return (Describe_keyspaces_result Nothing Nothing)
  res <- (Control.Exception.catch
    (do
      res <- Iface.describe_keyspaces handler
      return rs{f_Describe_keyspaces_result_success= Just res})
    (\e  -> 
      return rs{f_Describe_keyspaces_result_ire =Just e}))
  writeMessageBegin oprot ("describe_keyspaces", M_REPLY, seqid);
  write_Describe_keyspaces_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_cluster_name (seqid, iprot, oprot, handler) = do
  args <- read_Describe_cluster_name_args iprot
  readMessageEnd iprot
  rs <- return (Describe_cluster_name_result Nothing)
  res <- (do
    res <- Iface.describe_cluster_name handler
    return rs{f_Describe_cluster_name_result_success= Just res})
  writeMessageBegin oprot ("describe_cluster_name", M_REPLY, seqid);
  write_Describe_cluster_name_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_version (seqid, iprot, oprot, handler) = do
  args <- read_Describe_version_args iprot
  readMessageEnd iprot
  rs <- return (Describe_version_result Nothing)
  res <- (do
    res <- Iface.describe_version handler
    return rs{f_Describe_version_result_success= Just res})
  writeMessageBegin oprot ("describe_version", M_REPLY, seqid);
  write_Describe_version_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_ring (seqid, iprot, oprot, handler) = do
  args <- read_Describe_ring_args iprot
  readMessageEnd iprot
  rs <- return (Describe_ring_result Nothing Nothing)
  res <- (Control.Exception.catch
    (do
      res <- Iface.describe_ring handler (f_Describe_ring_args_keyspace args)
      return rs{f_Describe_ring_result_success= Just res})
    (\e  -> 
      return rs{f_Describe_ring_result_ire =Just e}))
  writeMessageBegin oprot ("describe_ring", M_REPLY, seqid);
  write_Describe_ring_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_partitioner (seqid, iprot, oprot, handler) = do
  args <- read_Describe_partitioner_args iprot
  readMessageEnd iprot
  rs <- return (Describe_partitioner_result Nothing)
  res <- (do
    res <- Iface.describe_partitioner handler
    return rs{f_Describe_partitioner_result_success= Just res})
  writeMessageBegin oprot ("describe_partitioner", M_REPLY, seqid);
  write_Describe_partitioner_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_snitch (seqid, iprot, oprot, handler) = do
  args <- read_Describe_snitch_args iprot
  readMessageEnd iprot
  rs <- return (Describe_snitch_result Nothing)
  res <- (do
    res <- Iface.describe_snitch handler
    return rs{f_Describe_snitch_result_success= Just res})
  writeMessageBegin oprot ("describe_snitch", M_REPLY, seqid);
  write_Describe_snitch_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_keyspace (seqid, iprot, oprot, handler) = do
  args <- read_Describe_keyspace_args iprot
  readMessageEnd iprot
  rs <- return (Describe_keyspace_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.describe_keyspace handler (f_Describe_keyspace_args_keyspace args)
        return rs{f_Describe_keyspace_result_success= Just res})
      (\e  -> 
        return rs{f_Describe_keyspace_result_nfe =Just e}))
    (\e  -> 
      return rs{f_Describe_keyspace_result_ire =Just e}))
  writeMessageBegin oprot ("describe_keyspace", M_REPLY, seqid);
  write_Describe_keyspace_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_describe_splits (seqid, iprot, oprot, handler) = do
  args <- read_Describe_splits_args iprot
  readMessageEnd iprot
  rs <- return (Describe_splits_result Nothing Nothing)
  res <- (Control.Exception.catch
    (do
      res <- Iface.describe_splits handler (f_Describe_splits_args_cfName args) (f_Describe_splits_args_start_token args) (f_Describe_splits_args_end_token args) (f_Describe_splits_args_keys_per_split args)
      return rs{f_Describe_splits_result_success= Just res})
    (\e  -> 
      return rs{f_Describe_splits_result_ire =Just e}))
  writeMessageBegin oprot ("describe_splits", M_REPLY, seqid);
  write_Describe_splits_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_add_column_family (seqid, iprot, oprot, handler) = do
  args <- read_System_add_column_family_args iprot
  readMessageEnd iprot
  rs <- return (System_add_column_family_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_add_column_family handler (f_System_add_column_family_args_cf_def args)
        return rs{f_System_add_column_family_result_success= Just res})
      (\e  -> 
        return rs{f_System_add_column_family_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_add_column_family_result_sde =Just e}))
  writeMessageBegin oprot ("system_add_column_family", M_REPLY, seqid);
  write_System_add_column_family_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_drop_column_family (seqid, iprot, oprot, handler) = do
  args <- read_System_drop_column_family_args iprot
  readMessageEnd iprot
  rs <- return (System_drop_column_family_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_drop_column_family handler (f_System_drop_column_family_args_column_family args)
        return rs{f_System_drop_column_family_result_success= Just res})
      (\e  -> 
        return rs{f_System_drop_column_family_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_drop_column_family_result_sde =Just e}))
  writeMessageBegin oprot ("system_drop_column_family", M_REPLY, seqid);
  write_System_drop_column_family_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_add_keyspace (seqid, iprot, oprot, handler) = do
  args <- read_System_add_keyspace_args iprot
  readMessageEnd iprot
  rs <- return (System_add_keyspace_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_add_keyspace handler (f_System_add_keyspace_args_ks_def args)
        return rs{f_System_add_keyspace_result_success= Just res})
      (\e  -> 
        return rs{f_System_add_keyspace_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_add_keyspace_result_sde =Just e}))
  writeMessageBegin oprot ("system_add_keyspace", M_REPLY, seqid);
  write_System_add_keyspace_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_drop_keyspace (seqid, iprot, oprot, handler) = do
  args <- read_System_drop_keyspace_args iprot
  readMessageEnd iprot
  rs <- return (System_drop_keyspace_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_drop_keyspace handler (f_System_drop_keyspace_args_keyspace args)
        return rs{f_System_drop_keyspace_result_success= Just res})
      (\e  -> 
        return rs{f_System_drop_keyspace_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_drop_keyspace_result_sde =Just e}))
  writeMessageBegin oprot ("system_drop_keyspace", M_REPLY, seqid);
  write_System_drop_keyspace_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_update_keyspace (seqid, iprot, oprot, handler) = do
  args <- read_System_update_keyspace_args iprot
  readMessageEnd iprot
  rs <- return (System_update_keyspace_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_update_keyspace handler (f_System_update_keyspace_args_ks_def args)
        return rs{f_System_update_keyspace_result_success= Just res})
      (\e  -> 
        return rs{f_System_update_keyspace_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_update_keyspace_result_sde =Just e}))
  writeMessageBegin oprot ("system_update_keyspace", M_REPLY, seqid);
  write_System_update_keyspace_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_system_update_column_family (seqid, iprot, oprot, handler) = do
  args <- read_System_update_column_family_args iprot
  readMessageEnd iprot
  rs <- return (System_update_column_family_result Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (do
        res <- Iface.system_update_column_family handler (f_System_update_column_family_args_cf_def args)
        return rs{f_System_update_column_family_result_success= Just res})
      (\e  -> 
        return rs{f_System_update_column_family_result_ire =Just e}))
    (\e  -> 
      return rs{f_System_update_column_family_result_sde =Just e}))
  writeMessageBegin oprot ("system_update_column_family", M_REPLY, seqid);
  write_System_update_column_family_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
process_execute_cql_query (seqid, iprot, oprot, handler) = do
  args <- read_Execute_cql_query_args iprot
  readMessageEnd iprot
  rs <- return (Execute_cql_query_result Nothing Nothing Nothing Nothing Nothing)
  res <- (Control.Exception.catch
    (Control.Exception.catch
      (Control.Exception.catch
        (Control.Exception.catch
          (do
            res <- Iface.execute_cql_query handler (f_Execute_cql_query_args_query args) (f_Execute_cql_query_args_compression args)
            return rs{f_Execute_cql_query_result_success= Just res})
          (\e  -> 
            return rs{f_Execute_cql_query_result_ire =Just e}))
        (\e  -> 
          return rs{f_Execute_cql_query_result_ue =Just e}))
      (\e  -> 
        return rs{f_Execute_cql_query_result_te =Just e}))
    (\e  -> 
      return rs{f_Execute_cql_query_result_sde =Just e}))
  writeMessageBegin oprot ("execute_cql_query", M_REPLY, seqid);
  write_Execute_cql_query_result oprot res
  writeMessageEnd oprot
  tFlush (getTransport oprot)
proc_ handler (iprot,oprot) (name,typ,seqid) = case name of
  "login" -> process_login (seqid,iprot,oprot,handler)
  "set_keyspace" -> process_set_keyspace (seqid,iprot,oprot,handler)
  "get" -> process_get (seqid,iprot,oprot,handler)
  "get_slice" -> process_get_slice (seqid,iprot,oprot,handler)
  "get_count" -> process_get_count (seqid,iprot,oprot,handler)
  "multiget_slice" -> process_multiget_slice (seqid,iprot,oprot,handler)
  "multiget_count" -> process_multiget_count (seqid,iprot,oprot,handler)
  "get_range_slices" -> process_get_range_slices (seqid,iprot,oprot,handler)
  "get_indexed_slices" -> process_get_indexed_slices (seqid,iprot,oprot,handler)
  "insert" -> process_insert (seqid,iprot,oprot,handler)
  "add" -> process_add (seqid,iprot,oprot,handler)
  "remove" -> process_remove (seqid,iprot,oprot,handler)
  "remove_counter" -> process_remove_counter (seqid,iprot,oprot,handler)
  "batch_mutate" -> process_batch_mutate (seqid,iprot,oprot,handler)
  "truncate" -> process_truncate (seqid,iprot,oprot,handler)
  "describe_schema_versions" -> process_describe_schema_versions (seqid,iprot,oprot,handler)
  "describe_keyspaces" -> process_describe_keyspaces (seqid,iprot,oprot,handler)
  "describe_cluster_name" -> process_describe_cluster_name (seqid,iprot,oprot,handler)
  "describe_version" -> process_describe_version (seqid,iprot,oprot,handler)
  "describe_ring" -> process_describe_ring (seqid,iprot,oprot,handler)
  "describe_partitioner" -> process_describe_partitioner (seqid,iprot,oprot,handler)
  "describe_snitch" -> process_describe_snitch (seqid,iprot,oprot,handler)
  "describe_keyspace" -> process_describe_keyspace (seqid,iprot,oprot,handler)
  "describe_splits" -> process_describe_splits (seqid,iprot,oprot,handler)
  "system_add_column_family" -> process_system_add_column_family (seqid,iprot,oprot,handler)
  "system_drop_column_family" -> process_system_drop_column_family (seqid,iprot,oprot,handler)
  "system_add_keyspace" -> process_system_add_keyspace (seqid,iprot,oprot,handler)
  "system_drop_keyspace" -> process_system_drop_keyspace (seqid,iprot,oprot,handler)
  "system_update_keyspace" -> process_system_update_keyspace (seqid,iprot,oprot,handler)
  "system_update_column_family" -> process_system_update_column_family (seqid,iprot,oprot,handler)
  "execute_cql_query" -> process_execute_cql_query (seqid,iprot,oprot,handler)
  _ -> do
    skip iprot T_STRUCT
    readMessageEnd iprot
    writeMessageBegin oprot (name,M_EXCEPTION,seqid)
    writeAppExn oprot (AppExn AE_UNKNOWN_METHOD ("Unknown function " ++ name))
    writeMessageEnd oprot
    tFlush (getTransport oprot)
process handler (iprot, oprot) = do
  (name, typ, seqid) <- readMessageBegin iprot
  proc_ handler (iprot,oprot) (name,typ,seqid)
  return True