#
# Autogenerated by Thrift Compiler (0.9.3)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TException, TApplicationException
import logging
from ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None


class Iface:
  def forbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def forbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
    """
    pass

  def forbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - device_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - device_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def forbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def taxiOrderHold(self, taxi_order_id, holdContent, isSend, sys_op_id):
    """
    Parameters:
     - taxi_order_id
     - holdContent
     - isSend
     - sys_op_id
    """
    pass

  def taxiOrderCancelHold(self, taxi_order_id, holdContent, sys_op_id):
    """
    Parameters:
     - taxi_order_id
     - holdContent
     - sys_op_id
    """
    pass

  def orderHold(self, order_id, holdContent, isSend, sys_op_id):
    """
    Parameters:
     - order_id
     - holdContent
     - isSend
     - sys_op_id
    """
    pass

  def orderCancelHold(self, order_id, holdContent, sys_op_id):
    """
    Parameters:
     - order_id
     - holdContent
     - sys_op_id
    """
    pass

  def taxiOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - order_id
     - sys_order_group
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def delReply(self, replyId):
    """
    Parameters:
     - replyId
    """
    pass

  def delReplyMulti(self, replyIds):
    """
    Parameters:
     - replyIds
    """
    pass

  def maskReply(self, replyId, mask):
    """
    Parameters:
     - replyId
     - mask
    """
    pass

  def maskReplyMulti(self, replyIds):
    """
    Parameters:
     - replyIds
    """
    pass

  def forbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
    """
    pass

  def forbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

  def unforbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def userOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - order_id
     - sys_order_group
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def createBatch(self, source, type, awardTime):
    """
    Parameters:
     - source
     - type
     - awardTime
    """
    pass

  def insertDetail(self, batchId, userId, balance, allOrderNum, actualOrderNum, cityId):
    """
    Parameters:
     - batchId
     - userId
     - balance
     - allOrderNum
     - actualOrderNum
     - cityId
    """
    pass

  def closeBatch(self, batchId):
    """
    Parameters:
     - batchId
    """
    pass

  def taxiOrderSetTagAndDebit(self, taxi_order_id, debitContent, sys_op_id, debitType, debitMoney):
    """
    Parameters:
     - taxi_order_id
     - debitContent
     - sys_op_id
     - debitType
     - debitMoney
    """
    pass

  def forbiddenDriverForCms(self, user_id, reason, sys_op_id, sys_op_ip, group_id, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
     - days
    """
    pass

  def saveOrUpdateUserTagCoupon(self, user_tag, coupon_set_ids):
    """
    Parameters:
     - user_tag
     - coupon_set_ids
    """
    pass

  def deleteUserTagCoupon(self, user_tag):
    """
    Parameters:
     - user_tag
    """
    pass

  def getTagCouponsByUserTags(self, user_tags):
    """
    Parameters:
     - user_tags
    """
    pass

  def punishForbiddenUser(self, user_id, sys_op_id, sys_op_ip, punish_id, reason):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - reason
    """
    pass

  def punishForbiddenTaxiUser(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - comment
    """
    pass

  def punishForbiddenTaxiDriver(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - comment
    """
    pass

  def cutTaxiDriverScore(self, user_id, change_score, punish_id, punish_type, ban_time, comment, sys_op_id, feedback_time, feedback_id):
    """
    Parameters:
     - user_id
     - change_score
     - punish_id
     - punish_type
     - ban_time
     - comment
     - sys_op_id
     - feedback_time
     - feedback_id
    """
    pass

  def addTaxiDriverScoreHis(self, user_id, change_score, score_id, ban_time, punish_id, comment, recover_time, sys_op_id, feedback_time, feedback_id):
    """
    Parameters:
     - user_id
     - change_score
     - score_id
     - ban_time
     - punish_id
     - comment
     - recover_time
     - sys_op_id
     - feedback_time
     - feedback_id
    """
    pass

  def checkTaxiDriverStatus(self, user_id, sys_op_id, change_score, ban_time, recover_time):
    """
    Parameters:
     - user_id
     - sys_op_id
     - change_score
     - ban_time
     - recover_time
    """
    pass

  def punishBanUserSubmitOrder(self, user_id, ban_time, punish_id, punish_type, sys_op_id):
    """
    Parameters:
     - user_id
     - ban_time
     - punish_id
     - punish_type
     - sys_op_id
    """
    pass

  def resetActionScore(self, user_id, comment, sys_op_id):
    """
    Parameters:
     - user_id
     - comment
     - sys_op_id
    """
    pass

  def getActiveRewardsByCityIdAndDate(self, city_id, date):
    """
    Parameters:
     - city_id
     - date
    """
    pass

  def addWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    pass

  def removeWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    pass

  def queryWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    pass

  def recordOrderComplaint(self, ride_id):
    """
    Parameters:
     - ride_id
    """
    pass

  def updateWithdrawState(self, user_id, type, state, remark, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - type
     - state
     - remark
     - sys_op_id
     - sys_op_ip
    """
    pass


class Client(Iface):
  def __init__(self, iprot, oprot=None):
    self._iprot = self._oprot = iprot
    if oprot is not None:
      self._oprot = oprot
    self._seqid = 0

  def forbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenUser(user_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenUser()

  def send_forbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenUser', TMessageType.CALL, self._seqid)
    args = forbiddenUser_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenUser failed: unknown result")

  def unforbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenUser(user_id, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenUser()

  def send_unforbiddenUser(self, user_id, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenUser', TMessageType.CALL, self._seqid)
    args = unforbiddenUser_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenUser failed: unknown result")

  def forbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenDriver(user_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenDriver()

  def send_forbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenDriver', TMessageType.CALL, self._seqid)
    args = forbiddenDriver_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenDriver(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenDriver_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenDriver failed: unknown result")

  def unforbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
    """
    self.send_unforbiddenDriver(user_id, reason, sys_op_id, sys_op_ip, group_id)
    return self.recv_unforbiddenDriver()

  def send_unforbiddenDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    self._oprot.writeMessageBegin('unforbiddenDriver', TMessageType.CALL, self._seqid)
    args = unforbiddenDriver_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.group_id = group_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenDriver(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenDriver_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenDriver failed: unknown result")

  def forbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - device_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenDevice(device_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenDevice()

  def send_forbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenDevice', TMessageType.CALL, self._seqid)
    args = forbiddenDevice_args()
    args.device_id = device_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenDevice(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenDevice_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenDevice failed: unknown result")

  def unforbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - device_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenDevice(device_id, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenDevice()

  def send_unforbiddenDevice(self, device_id, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenDevice', TMessageType.CALL, self._seqid)
    args = unforbiddenDevice_args()
    args.device_id = device_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenDevice(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenDevice_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenDevice failed: unknown result")

  def forbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenPost(user_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenPost()

  def send_forbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenPost', TMessageType.CALL, self._seqid)
    args = forbiddenPost_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenPost(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenPost_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenPost failed: unknown result")

  def unforbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenPost(user_id, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenPost()

  def send_unforbiddenPost(self, user_id, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenPost', TMessageType.CALL, self._seqid)
    args = unforbiddenPost_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenPost(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenPost_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenPost failed: unknown result")

  def taxiOrderHold(self, taxi_order_id, holdContent, isSend, sys_op_id):
    """
    Parameters:
     - taxi_order_id
     - holdContent
     - isSend
     - sys_op_id
    """
    self.send_taxiOrderHold(taxi_order_id, holdContent, isSend, sys_op_id)
    return self.recv_taxiOrderHold()

  def send_taxiOrderHold(self, taxi_order_id, holdContent, isSend, sys_op_id):
    self._oprot.writeMessageBegin('taxiOrderHold', TMessageType.CALL, self._seqid)
    args = taxiOrderHold_args()
    args.taxi_order_id = taxi_order_id
    args.holdContent = holdContent
    args.isSend = isSend
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_taxiOrderHold(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = taxiOrderHold_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxiOrderHold failed: unknown result")

  def taxiOrderCancelHold(self, taxi_order_id, holdContent, sys_op_id):
    """
    Parameters:
     - taxi_order_id
     - holdContent
     - sys_op_id
    """
    self.send_taxiOrderCancelHold(taxi_order_id, holdContent, sys_op_id)
    return self.recv_taxiOrderCancelHold()

  def send_taxiOrderCancelHold(self, taxi_order_id, holdContent, sys_op_id):
    self._oprot.writeMessageBegin('taxiOrderCancelHold', TMessageType.CALL, self._seqid)
    args = taxiOrderCancelHold_args()
    args.taxi_order_id = taxi_order_id
    args.holdContent = holdContent
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_taxiOrderCancelHold(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = taxiOrderCancelHold_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxiOrderCancelHold failed: unknown result")

  def orderHold(self, order_id, holdContent, isSend, sys_op_id):
    """
    Parameters:
     - order_id
     - holdContent
     - isSend
     - sys_op_id
    """
    self.send_orderHold(order_id, holdContent, isSend, sys_op_id)
    return self.recv_orderHold()

  def send_orderHold(self, order_id, holdContent, isSend, sys_op_id):
    self._oprot.writeMessageBegin('orderHold', TMessageType.CALL, self._seqid)
    args = orderHold_args()
    args.order_id = order_id
    args.holdContent = holdContent
    args.isSend = isSend
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_orderHold(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = orderHold_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "orderHold failed: unknown result")

  def orderCancelHold(self, order_id, holdContent, sys_op_id):
    """
    Parameters:
     - order_id
     - holdContent
     - sys_op_id
    """
    self.send_orderCancelHold(order_id, holdContent, sys_op_id)
    return self.recv_orderCancelHold()

  def send_orderCancelHold(self, order_id, holdContent, sys_op_id):
    self._oprot.writeMessageBegin('orderCancelHold', TMessageType.CALL, self._seqid)
    args = orderCancelHold_args()
    args.order_id = order_id
    args.holdContent = holdContent
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_orderCancelHold(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = orderCancelHold_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "orderCancelHold failed: unknown result")

  def taxiOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - order_id
     - sys_order_group
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_taxiOrderSetTag(order_id, sys_order_group, reason, sys_op_id, sys_op_ip)
    return self.recv_taxiOrderSetTag()

  def send_taxiOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('taxiOrderSetTag', TMessageType.CALL, self._seqid)
    args = taxiOrderSetTag_args()
    args.order_id = order_id
    args.sys_order_group = sys_order_group
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_taxiOrderSetTag(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = taxiOrderSetTag_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxiOrderSetTag failed: unknown result")

  def delReply(self, replyId):
    """
    Parameters:
     - replyId
    """
    self.send_delReply(replyId)
    return self.recv_delReply()

  def send_delReply(self, replyId):
    self._oprot.writeMessageBegin('delReply', TMessageType.CALL, self._seqid)
    args = delReply_args()
    args.replyId = replyId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_delReply(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = delReply_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "delReply failed: unknown result")

  def delReplyMulti(self, replyIds):
    """
    Parameters:
     - replyIds
    """
    self.send_delReplyMulti(replyIds)
    return self.recv_delReplyMulti()

  def send_delReplyMulti(self, replyIds):
    self._oprot.writeMessageBegin('delReplyMulti', TMessageType.CALL, self._seqid)
    args = delReplyMulti_args()
    args.replyIds = replyIds
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_delReplyMulti(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = delReplyMulti_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "delReplyMulti failed: unknown result")

  def maskReply(self, replyId, mask):
    """
    Parameters:
     - replyId
     - mask
    """
    self.send_maskReply(replyId, mask)
    return self.recv_maskReply()

  def send_maskReply(self, replyId, mask):
    self._oprot.writeMessageBegin('maskReply', TMessageType.CALL, self._seqid)
    args = maskReply_args()
    args.replyId = replyId
    args.mask = mask
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_maskReply(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = maskReply_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "maskReply failed: unknown result")

  def maskReplyMulti(self, replyIds):
    """
    Parameters:
     - replyIds
    """
    self.send_maskReplyMulti(replyIds)
    return self.recv_maskReplyMulti()

  def send_maskReplyMulti(self, replyIds):
    self._oprot.writeMessageBegin('maskReplyMulti', TMessageType.CALL, self._seqid)
    args = maskReplyMulti_args()
    args.replyIds = replyIds
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_maskReplyMulti(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = maskReplyMulti_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "maskReplyMulti failed: unknown result")

  def forbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenTaxiDriver(user_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenTaxiDriver()

  def send_forbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenTaxiDriver', TMessageType.CALL, self._seqid)
    args = forbiddenTaxiDriver_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenTaxiDriver(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenTaxiDriver_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenTaxiDriver failed: unknown result")

  def unforbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
    """
    self.send_unforbiddenTaxiDriver(user_id, reason, sys_op_id, sys_op_ip, group_id)
    return self.recv_unforbiddenTaxiDriver()

  def send_unforbiddenTaxiDriver(self, user_id, reason, sys_op_id, sys_op_ip, group_id):
    self._oprot.writeMessageBegin('unforbiddenTaxiDriver', TMessageType.CALL, self._seqid)
    args = unforbiddenTaxiDriver_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.group_id = group_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenTaxiDriver(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenTaxiDriver_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenTaxiDriver failed: unknown result")

  def forbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenTaxiUser(user_id, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenTaxiUser()

  def send_forbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenTaxiUser', TMessageType.CALL, self._seqid)
    args = forbiddenTaxiUser_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenTaxiUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenTaxiUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenTaxiUser failed: unknown result")

  def unforbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenTaxiUser(user_id, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenTaxiUser()

  def send_unforbiddenTaxiUser(self, user_id, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenTaxiUser', TMessageType.CALL, self._seqid)
    args = unforbiddenTaxiUser_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_unforbiddenTaxiUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = unforbiddenTaxiUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "unforbiddenTaxiUser failed: unknown result")

  def userOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - order_id
     - sys_order_group
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_userOrderSetTag(order_id, sys_order_group, reason, sys_op_id, sys_op_ip)
    return self.recv_userOrderSetTag()

  def send_userOrderSetTag(self, order_id, sys_order_group, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('userOrderSetTag', TMessageType.CALL, self._seqid)
    args = userOrderSetTag_args()
    args.order_id = order_id
    args.sys_order_group = sys_order_group
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_userOrderSetTag(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = userOrderSetTag_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userOrderSetTag failed: unknown result")

  def createBatch(self, source, type, awardTime):
    """
    Parameters:
     - source
     - type
     - awardTime
    """
    self.send_createBatch(source, type, awardTime)
    return self.recv_createBatch()

  def send_createBatch(self, source, type, awardTime):
    self._oprot.writeMessageBegin('createBatch', TMessageType.CALL, self._seqid)
    args = createBatch_args()
    args.source = source
    args.type = type
    args.awardTime = awardTime
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createBatch(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = createBatch_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createBatch failed: unknown result")

  def insertDetail(self, batchId, userId, balance, allOrderNum, actualOrderNum, cityId):
    """
    Parameters:
     - batchId
     - userId
     - balance
     - allOrderNum
     - actualOrderNum
     - cityId
    """
    self.send_insertDetail(batchId, userId, balance, allOrderNum, actualOrderNum, cityId)
    return self.recv_insertDetail()

  def send_insertDetail(self, batchId, userId, balance, allOrderNum, actualOrderNum, cityId):
    self._oprot.writeMessageBegin('insertDetail', TMessageType.CALL, self._seqid)
    args = insertDetail_args()
    args.batchId = batchId
    args.userId = userId
    args.balance = balance
    args.allOrderNum = allOrderNum
    args.actualOrderNum = actualOrderNum
    args.cityId = cityId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_insertDetail(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = insertDetail_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insertDetail failed: unknown result")

  def closeBatch(self, batchId):
    """
    Parameters:
     - batchId
    """
    self.send_closeBatch(batchId)
    return self.recv_closeBatch()

  def send_closeBatch(self, batchId):
    self._oprot.writeMessageBegin('closeBatch', TMessageType.CALL, self._seqid)
    args = closeBatch_args()
    args.batchId = batchId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_closeBatch(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = closeBatch_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "closeBatch failed: unknown result")

  def taxiOrderSetTagAndDebit(self, taxi_order_id, debitContent, sys_op_id, debitType, debitMoney):
    """
    Parameters:
     - taxi_order_id
     - debitContent
     - sys_op_id
     - debitType
     - debitMoney
    """
    self.send_taxiOrderSetTagAndDebit(taxi_order_id, debitContent, sys_op_id, debitType, debitMoney)
    return self.recv_taxiOrderSetTagAndDebit()

  def send_taxiOrderSetTagAndDebit(self, taxi_order_id, debitContent, sys_op_id, debitType, debitMoney):
    self._oprot.writeMessageBegin('taxiOrderSetTagAndDebit', TMessageType.CALL, self._seqid)
    args = taxiOrderSetTagAndDebit_args()
    args.taxi_order_id = taxi_order_id
    args.debitContent = debitContent
    args.sys_op_id = sys_op_id
    args.debitType = debitType
    args.debitMoney = debitMoney
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_taxiOrderSetTagAndDebit(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = taxiOrderSetTagAndDebit_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxiOrderSetTagAndDebit failed: unknown result")

  def forbiddenDriverForCms(self, user_id, reason, sys_op_id, sys_op_ip, group_id, days):
    """
    Parameters:
     - user_id
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
     - days
    """
    self.send_forbiddenDriverForCms(user_id, reason, sys_op_id, sys_op_ip, group_id, days)
    return self.recv_forbiddenDriverForCms()

  def send_forbiddenDriverForCms(self, user_id, reason, sys_op_id, sys_op_ip, group_id, days):
    self._oprot.writeMessageBegin('forbiddenDriverForCms', TMessageType.CALL, self._seqid)
    args = forbiddenDriverForCms_args()
    args.user_id = user_id
    args.reason = reason
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.group_id = group_id
    args.days = days
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_forbiddenDriverForCms(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = forbiddenDriverForCms_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forbiddenDriverForCms failed: unknown result")

  def saveOrUpdateUserTagCoupon(self, user_tag, coupon_set_ids):
    """
    Parameters:
     - user_tag
     - coupon_set_ids
    """
    self.send_saveOrUpdateUserTagCoupon(user_tag, coupon_set_ids)
    return self.recv_saveOrUpdateUserTagCoupon()

  def send_saveOrUpdateUserTagCoupon(self, user_tag, coupon_set_ids):
    self._oprot.writeMessageBegin('saveOrUpdateUserTagCoupon', TMessageType.CALL, self._seqid)
    args = saveOrUpdateUserTagCoupon_args()
    args.user_tag = user_tag
    args.coupon_set_ids = coupon_set_ids
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_saveOrUpdateUserTagCoupon(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = saveOrUpdateUserTagCoupon_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveOrUpdateUserTagCoupon failed: unknown result")

  def deleteUserTagCoupon(self, user_tag):
    """
    Parameters:
     - user_tag
    """
    self.send_deleteUserTagCoupon(user_tag)
    return self.recv_deleteUserTagCoupon()

  def send_deleteUserTagCoupon(self, user_tag):
    self._oprot.writeMessageBegin('deleteUserTagCoupon', TMessageType.CALL, self._seqid)
    args = deleteUserTagCoupon_args()
    args.user_tag = user_tag
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_deleteUserTagCoupon(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = deleteUserTagCoupon_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUserTagCoupon failed: unknown result")

  def getTagCouponsByUserTags(self, user_tags):
    """
    Parameters:
     - user_tags
    """
    self.send_getTagCouponsByUserTags(user_tags)
    return self.recv_getTagCouponsByUserTags()

  def send_getTagCouponsByUserTags(self, user_tags):
    self._oprot.writeMessageBegin('getTagCouponsByUserTags', TMessageType.CALL, self._seqid)
    args = getTagCouponsByUserTags_args()
    args.user_tags = user_tags
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTagCouponsByUserTags(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = getTagCouponsByUserTags_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTagCouponsByUserTags failed: unknown result")

  def punishForbiddenUser(self, user_id, sys_op_id, sys_op_ip, punish_id, reason):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - reason
    """
    self.send_punishForbiddenUser(user_id, sys_op_id, sys_op_ip, punish_id, reason)
    return self.recv_punishForbiddenUser()

  def send_punishForbiddenUser(self, user_id, sys_op_id, sys_op_ip, punish_id, reason):
    self._oprot.writeMessageBegin('punishForbiddenUser', TMessageType.CALL, self._seqid)
    args = punishForbiddenUser_args()
    args.user_id = user_id
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.punish_id = punish_id
    args.reason = reason
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_punishForbiddenUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = punishForbiddenUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "punishForbiddenUser failed: unknown result")

  def punishForbiddenTaxiUser(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - comment
    """
    self.send_punishForbiddenTaxiUser(user_id, sys_op_id, sys_op_ip, punish_id, comment)
    return self.recv_punishForbiddenTaxiUser()

  def send_punishForbiddenTaxiUser(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    self._oprot.writeMessageBegin('punishForbiddenTaxiUser', TMessageType.CALL, self._seqid)
    args = punishForbiddenTaxiUser_args()
    args.user_id = user_id
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.punish_id = punish_id
    args.comment = comment
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_punishForbiddenTaxiUser(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = punishForbiddenTaxiUser_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "punishForbiddenTaxiUser failed: unknown result")

  def punishForbiddenTaxiDriver(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    """
    Parameters:
     - user_id
     - sys_op_id
     - sys_op_ip
     - punish_id
     - comment
    """
    self.send_punishForbiddenTaxiDriver(user_id, sys_op_id, sys_op_ip, punish_id, comment)
    return self.recv_punishForbiddenTaxiDriver()

  def send_punishForbiddenTaxiDriver(self, user_id, sys_op_id, sys_op_ip, punish_id, comment):
    self._oprot.writeMessageBegin('punishForbiddenTaxiDriver', TMessageType.CALL, self._seqid)
    args = punishForbiddenTaxiDriver_args()
    args.user_id = user_id
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.punish_id = punish_id
    args.comment = comment
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_punishForbiddenTaxiDriver(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = punishForbiddenTaxiDriver_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "punishForbiddenTaxiDriver failed: unknown result")

  def cutTaxiDriverScore(self, user_id, change_score, punish_id, punish_type, ban_time, comment, sys_op_id, feedback_time, feedback_id):
    """
    Parameters:
     - user_id
     - change_score
     - punish_id
     - punish_type
     - ban_time
     - comment
     - sys_op_id
     - feedback_time
     - feedback_id
    """
    self.send_cutTaxiDriverScore(user_id, change_score, punish_id, punish_type, ban_time, comment, sys_op_id, feedback_time, feedback_id)
    return self.recv_cutTaxiDriverScore()

  def send_cutTaxiDriverScore(self, user_id, change_score, punish_id, punish_type, ban_time, comment, sys_op_id, feedback_time, feedback_id):
    self._oprot.writeMessageBegin('cutTaxiDriverScore', TMessageType.CALL, self._seqid)
    args = cutTaxiDriverScore_args()
    args.user_id = user_id
    args.change_score = change_score
    args.punish_id = punish_id
    args.punish_type = punish_type
    args.ban_time = ban_time
    args.comment = comment
    args.sys_op_id = sys_op_id
    args.feedback_time = feedback_time
    args.feedback_id = feedback_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_cutTaxiDriverScore(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = cutTaxiDriverScore_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cutTaxiDriverScore failed: unknown result")

  def addTaxiDriverScoreHis(self, user_id, change_score, score_id, ban_time, punish_id, comment, recover_time, sys_op_id, feedback_time, feedback_id):
    """
    Parameters:
     - user_id
     - change_score
     - score_id
     - ban_time
     - punish_id
     - comment
     - recover_time
     - sys_op_id
     - feedback_time
     - feedback_id
    """
    self.send_addTaxiDriverScoreHis(user_id, change_score, score_id, ban_time, punish_id, comment, recover_time, sys_op_id, feedback_time, feedback_id)
    return self.recv_addTaxiDriverScoreHis()

  def send_addTaxiDriverScoreHis(self, user_id, change_score, score_id, ban_time, punish_id, comment, recover_time, sys_op_id, feedback_time, feedback_id):
    self._oprot.writeMessageBegin('addTaxiDriverScoreHis', TMessageType.CALL, self._seqid)
    args = addTaxiDriverScoreHis_args()
    args.user_id = user_id
    args.change_score = change_score
    args.score_id = score_id
    args.ban_time = ban_time
    args.punish_id = punish_id
    args.comment = comment
    args.recover_time = recover_time
    args.sys_op_id = sys_op_id
    args.feedback_time = feedback_time
    args.feedback_id = feedback_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addTaxiDriverScoreHis(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = addTaxiDriverScoreHis_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTaxiDriverScoreHis failed: unknown result")

  def checkTaxiDriverStatus(self, user_id, sys_op_id, change_score, ban_time, recover_time):
    """
    Parameters:
     - user_id
     - sys_op_id
     - change_score
     - ban_time
     - recover_time
    """
    self.send_checkTaxiDriverStatus(user_id, sys_op_id, change_score, ban_time, recover_time)
    return self.recv_checkTaxiDriverStatus()

  def send_checkTaxiDriverStatus(self, user_id, sys_op_id, change_score, ban_time, recover_time):
    self._oprot.writeMessageBegin('checkTaxiDriverStatus', TMessageType.CALL, self._seqid)
    args = checkTaxiDriverStatus_args()
    args.user_id = user_id
    args.sys_op_id = sys_op_id
    args.change_score = change_score
    args.ban_time = ban_time
    args.recover_time = recover_time
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkTaxiDriverStatus(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = checkTaxiDriverStatus_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkTaxiDriverStatus failed: unknown result")

  def punishBanUserSubmitOrder(self, user_id, ban_time, punish_id, punish_type, sys_op_id):
    """
    Parameters:
     - user_id
     - ban_time
     - punish_id
     - punish_type
     - sys_op_id
    """
    self.send_punishBanUserSubmitOrder(user_id, ban_time, punish_id, punish_type, sys_op_id)
    return self.recv_punishBanUserSubmitOrder()

  def send_punishBanUserSubmitOrder(self, user_id, ban_time, punish_id, punish_type, sys_op_id):
    self._oprot.writeMessageBegin('punishBanUserSubmitOrder', TMessageType.CALL, self._seqid)
    args = punishBanUserSubmitOrder_args()
    args.user_id = user_id
    args.ban_time = ban_time
    args.punish_id = punish_id
    args.punish_type = punish_type
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_punishBanUserSubmitOrder(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = punishBanUserSubmitOrder_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "punishBanUserSubmitOrder failed: unknown result")

  def resetActionScore(self, user_id, comment, sys_op_id):
    """
    Parameters:
     - user_id
     - comment
     - sys_op_id
    """
    self.send_resetActionScore(user_id, comment, sys_op_id)
    return self.recv_resetActionScore()

  def send_resetActionScore(self, user_id, comment, sys_op_id):
    self._oprot.writeMessageBegin('resetActionScore', TMessageType.CALL, self._seqid)
    args = resetActionScore_args()
    args.user_id = user_id
    args.comment = comment
    args.sys_op_id = sys_op_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_resetActionScore(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = resetActionScore_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetActionScore failed: unknown result")

  def getActiveRewardsByCityIdAndDate(self, city_id, date):
    """
    Parameters:
     - city_id
     - date
    """
    self.send_getActiveRewardsByCityIdAndDate(city_id, date)
    return self.recv_getActiveRewardsByCityIdAndDate()

  def send_getActiveRewardsByCityIdAndDate(self, city_id, date):
    self._oprot.writeMessageBegin('getActiveRewardsByCityIdAndDate', TMessageType.CALL, self._seqid)
    args = getActiveRewardsByCityIdAndDate_args()
    args.city_id = city_id
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getActiveRewardsByCityIdAndDate(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = getActiveRewardsByCityIdAndDate_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveRewardsByCityIdAndDate failed: unknown result")

  def addWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    self.send_addWhiteDevice(device)
    return self.recv_addWhiteDevice()

  def send_addWhiteDevice(self, device):
    self._oprot.writeMessageBegin('addWhiteDevice', TMessageType.CALL, self._seqid)
    args = addWhiteDevice_args()
    args.device = device
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_addWhiteDevice(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = addWhiteDevice_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addWhiteDevice failed: unknown result")

  def removeWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    self.send_removeWhiteDevice(device)
    return self.recv_removeWhiteDevice()

  def send_removeWhiteDevice(self, device):
    self._oprot.writeMessageBegin('removeWhiteDevice', TMessageType.CALL, self._seqid)
    args = removeWhiteDevice_args()
    args.device = device
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_removeWhiteDevice(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = removeWhiteDevice_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeWhiteDevice failed: unknown result")

  def queryWhiteDevice(self, device):
    """
    Parameters:
     - device
    """
    self.send_queryWhiteDevice(device)
    return self.recv_queryWhiteDevice()

  def send_queryWhiteDevice(self, device):
    self._oprot.writeMessageBegin('queryWhiteDevice', TMessageType.CALL, self._seqid)
    args = queryWhiteDevice_args()
    args.device = device
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_queryWhiteDevice(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = queryWhiteDevice_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "queryWhiteDevice failed: unknown result")

  def recordOrderComplaint(self, ride_id):
    """
    Parameters:
     - ride_id
    """
    self.send_recordOrderComplaint(ride_id)
    return self.recv_recordOrderComplaint()

  def send_recordOrderComplaint(self, ride_id):
    self._oprot.writeMessageBegin('recordOrderComplaint', TMessageType.CALL, self._seqid)
    args = recordOrderComplaint_args()
    args.ride_id = ride_id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_recordOrderComplaint(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = recordOrderComplaint_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "recordOrderComplaint failed: unknown result")

  def updateWithdrawState(self, user_id, type, state, remark, sys_op_id, sys_op_ip):
    """
    Parameters:
     - user_id
     - type
     - state
     - remark
     - sys_op_id
     - sys_op_ip
    """
    self.send_updateWithdrawState(user_id, type, state, remark, sys_op_id, sys_op_ip)
    return self.recv_updateWithdrawState()

  def send_updateWithdrawState(self, user_id, type, state, remark, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('updateWithdrawState', TMessageType.CALL, self._seqid)
    args = updateWithdrawState_args()
    args.user_id = user_id
    args.type = type
    args.state = state
    args.remark = remark
    args.sys_op_id = sys_op_id
    args.sys_op_ip = sys_op_ip
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateWithdrawState(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = updateWithdrawState_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWithdrawState failed: unknown result")


class Processor(Iface, TProcessor):
  def __init__(self, handler):
    self._handler = handler
    self._processMap = {}
    self._processMap["forbiddenUser"] = Processor.process_forbiddenUser
    self._processMap["unforbiddenUser"] = Processor.process_unforbiddenUser
    self._processMap["forbiddenDriver"] = Processor.process_forbiddenDriver
    self._processMap["unforbiddenDriver"] = Processor.process_unforbiddenDriver
    self._processMap["forbiddenDevice"] = Processor.process_forbiddenDevice
    self._processMap["unforbiddenDevice"] = Processor.process_unforbiddenDevice
    self._processMap["forbiddenPost"] = Processor.process_forbiddenPost
    self._processMap["unforbiddenPost"] = Processor.process_unforbiddenPost
    self._processMap["taxiOrderHold"] = Processor.process_taxiOrderHold
    self._processMap["taxiOrderCancelHold"] = Processor.process_taxiOrderCancelHold
    self._processMap["orderHold"] = Processor.process_orderHold
    self._processMap["orderCancelHold"] = Processor.process_orderCancelHold
    self._processMap["taxiOrderSetTag"] = Processor.process_taxiOrderSetTag
    self._processMap["delReply"] = Processor.process_delReply
    self._processMap["delReplyMulti"] = Processor.process_delReplyMulti
    self._processMap["maskReply"] = Processor.process_maskReply
    self._processMap["maskReplyMulti"] = Processor.process_maskReplyMulti
    self._processMap["forbiddenTaxiDriver"] = Processor.process_forbiddenTaxiDriver
    self._processMap["unforbiddenTaxiDriver"] = Processor.process_unforbiddenTaxiDriver
    self._processMap["forbiddenTaxiUser"] = Processor.process_forbiddenTaxiUser
    self._processMap["unforbiddenTaxiUser"] = Processor.process_unforbiddenTaxiUser
    self._processMap["userOrderSetTag"] = Processor.process_userOrderSetTag
    self._processMap["createBatch"] = Processor.process_createBatch
    self._processMap["insertDetail"] = Processor.process_insertDetail
    self._processMap["closeBatch"] = Processor.process_closeBatch
    self._processMap["taxiOrderSetTagAndDebit"] = Processor.process_taxiOrderSetTagAndDebit
    self._processMap["forbiddenDriverForCms"] = Processor.process_forbiddenDriverForCms
    self._processMap["saveOrUpdateUserTagCoupon"] = Processor.process_saveOrUpdateUserTagCoupon
    self._processMap["deleteUserTagCoupon"] = Processor.process_deleteUserTagCoupon
    self._processMap["getTagCouponsByUserTags"] = Processor.process_getTagCouponsByUserTags
    self._processMap["punishForbiddenUser"] = Processor.process_punishForbiddenUser
    self._processMap["punishForbiddenTaxiUser"] = Processor.process_punishForbiddenTaxiUser
    self._processMap["punishForbiddenTaxiDriver"] = Processor.process_punishForbiddenTaxiDriver
    self._processMap["cutTaxiDriverScore"] = Processor.process_cutTaxiDriverScore
    self._processMap["addTaxiDriverScoreHis"] = Processor.process_addTaxiDriverScoreHis
    self._processMap["checkTaxiDriverStatus"] = Processor.process_checkTaxiDriverStatus
    self._processMap["punishBanUserSubmitOrder"] = Processor.process_punishBanUserSubmitOrder
    self._processMap["resetActionScore"] = Processor.process_resetActionScore
    self._processMap["getActiveRewardsByCityIdAndDate"] = Processor.process_getActiveRewardsByCityIdAndDate
    self._processMap["addWhiteDevice"] = Processor.process_addWhiteDevice
    self._processMap["removeWhiteDevice"] = Processor.process_removeWhiteDevice
    self._processMap["queryWhiteDevice"] = Processor.process_queryWhiteDevice
    self._processMap["recordOrderComplaint"] = Processor.process_recordOrderComplaint
    self._processMap["updateWithdrawState"] = Processor.process_updateWithdrawState

  def process(self, iprot, oprot):
    (name, type, seqid) = iprot.readMessageBegin()
    if name not in self._processMap:
      iprot.skip(TType.STRUCT)
      iprot.readMessageEnd()
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
      x.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
      return
    else:
      self._processMap[name](self, seqid, iprot, oprot)
    return True

  def process_forbiddenUser(self, seqid, iprot, oprot):
    args = forbiddenUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenUser_result()
    try:
      result.success = self._handler.forbiddenUser(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenUser(self, seqid, iprot, oprot):
    args = unforbiddenUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenUser_result()
    try:
      result.success = self._handler.unforbiddenUser(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenDriver(self, seqid, iprot, oprot):
    args = forbiddenDriver_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenDriver_result()
    try:
      result.success = self._handler.forbiddenDriver(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenDriver", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenDriver(self, seqid, iprot, oprot):
    args = unforbiddenDriver_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenDriver_result()
    try:
      result.success = self._handler.unforbiddenDriver(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.group_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenDriver", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenDevice(self, seqid, iprot, oprot):
    args = forbiddenDevice_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenDevice_result()
    try:
      result.success = self._handler.forbiddenDevice(args.device_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenDevice", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenDevice(self, seqid, iprot, oprot):
    args = unforbiddenDevice_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenDevice_result()
    try:
      result.success = self._handler.unforbiddenDevice(args.device_id, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenDevice", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenPost(self, seqid, iprot, oprot):
    args = forbiddenPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenPost_result()
    try:
      result.success = self._handler.forbiddenPost(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenPost(self, seqid, iprot, oprot):
    args = unforbiddenPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenPost_result()
    try:
      result.success = self._handler.unforbiddenPost(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_taxiOrderHold(self, seqid, iprot, oprot):
    args = taxiOrderHold_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = taxiOrderHold_result()
    try:
      result.success = self._handler.taxiOrderHold(args.taxi_order_id, args.holdContent, args.isSend, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("taxiOrderHold", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_taxiOrderCancelHold(self, seqid, iprot, oprot):
    args = taxiOrderCancelHold_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = taxiOrderCancelHold_result()
    try:
      result.success = self._handler.taxiOrderCancelHold(args.taxi_order_id, args.holdContent, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("taxiOrderCancelHold", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_orderHold(self, seqid, iprot, oprot):
    args = orderHold_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = orderHold_result()
    try:
      result.success = self._handler.orderHold(args.order_id, args.holdContent, args.isSend, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("orderHold", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_orderCancelHold(self, seqid, iprot, oprot):
    args = orderCancelHold_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = orderCancelHold_result()
    try:
      result.success = self._handler.orderCancelHold(args.order_id, args.holdContent, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("orderCancelHold", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_taxiOrderSetTag(self, seqid, iprot, oprot):
    args = taxiOrderSetTag_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = taxiOrderSetTag_result()
    try:
      result.success = self._handler.taxiOrderSetTag(args.order_id, args.sys_order_group, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("taxiOrderSetTag", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_delReply(self, seqid, iprot, oprot):
    args = delReply_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = delReply_result()
    try:
      result.success = self._handler.delReply(args.replyId)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("delReply", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_delReplyMulti(self, seqid, iprot, oprot):
    args = delReplyMulti_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = delReplyMulti_result()
    try:
      result.success = self._handler.delReplyMulti(args.replyIds)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("delReplyMulti", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_maskReply(self, seqid, iprot, oprot):
    args = maskReply_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = maskReply_result()
    try:
      result.success = self._handler.maskReply(args.replyId, args.mask)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("maskReply", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_maskReplyMulti(self, seqid, iprot, oprot):
    args = maskReplyMulti_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = maskReplyMulti_result()
    try:
      result.success = self._handler.maskReplyMulti(args.replyIds)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("maskReplyMulti", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenTaxiDriver(self, seqid, iprot, oprot):
    args = forbiddenTaxiDriver_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenTaxiDriver_result()
    try:
      result.success = self._handler.forbiddenTaxiDriver(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenTaxiDriver", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenTaxiDriver(self, seqid, iprot, oprot):
    args = unforbiddenTaxiDriver_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenTaxiDriver_result()
    try:
      result.success = self._handler.unforbiddenTaxiDriver(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.group_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenTaxiDriver", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenTaxiUser(self, seqid, iprot, oprot):
    args = forbiddenTaxiUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenTaxiUser_result()
    try:
      result.success = self._handler.forbiddenTaxiUser(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenTaxiUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_unforbiddenTaxiUser(self, seqid, iprot, oprot):
    args = unforbiddenTaxiUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = unforbiddenTaxiUser_result()
    try:
      result.success = self._handler.unforbiddenTaxiUser(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("unforbiddenTaxiUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_userOrderSetTag(self, seqid, iprot, oprot):
    args = userOrderSetTag_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = userOrderSetTag_result()
    try:
      result.success = self._handler.userOrderSetTag(args.order_id, args.sys_order_group, args.reason, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("userOrderSetTag", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createBatch(self, seqid, iprot, oprot):
    args = createBatch_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createBatch_result()
    try:
      result.success = self._handler.createBatch(args.source, args.type, args.awardTime)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("createBatch", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_insertDetail(self, seqid, iprot, oprot):
    args = insertDetail_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = insertDetail_result()
    try:
      result.success = self._handler.insertDetail(args.batchId, args.userId, args.balance, args.allOrderNum, args.actualOrderNum, args.cityId)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("insertDetail", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_closeBatch(self, seqid, iprot, oprot):
    args = closeBatch_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = closeBatch_result()
    try:
      result.success = self._handler.closeBatch(args.batchId)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("closeBatch", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_taxiOrderSetTagAndDebit(self, seqid, iprot, oprot):
    args = taxiOrderSetTagAndDebit_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = taxiOrderSetTagAndDebit_result()
    try:
      result.success = self._handler.taxiOrderSetTagAndDebit(args.taxi_order_id, args.debitContent, args.sys_op_id, args.debitType, args.debitMoney)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("taxiOrderSetTagAndDebit", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_forbiddenDriverForCms(self, seqid, iprot, oprot):
    args = forbiddenDriverForCms_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = forbiddenDriverForCms_result()
    try:
      result.success = self._handler.forbiddenDriverForCms(args.user_id, args.reason, args.sys_op_id, args.sys_op_ip, args.group_id, args.days)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("forbiddenDriverForCms", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_saveOrUpdateUserTagCoupon(self, seqid, iprot, oprot):
    args = saveOrUpdateUserTagCoupon_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = saveOrUpdateUserTagCoupon_result()
    try:
      result.success = self._handler.saveOrUpdateUserTagCoupon(args.user_tag, args.coupon_set_ids)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("saveOrUpdateUserTagCoupon", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_deleteUserTagCoupon(self, seqid, iprot, oprot):
    args = deleteUserTagCoupon_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = deleteUserTagCoupon_result()
    try:
      result.success = self._handler.deleteUserTagCoupon(args.user_tag)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("deleteUserTagCoupon", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTagCouponsByUserTags(self, seqid, iprot, oprot):
    args = getTagCouponsByUserTags_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTagCouponsByUserTags_result()
    try:
      result.success = self._handler.getTagCouponsByUserTags(args.user_tags)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("getTagCouponsByUserTags", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_punishForbiddenUser(self, seqid, iprot, oprot):
    args = punishForbiddenUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = punishForbiddenUser_result()
    try:
      result.success = self._handler.punishForbiddenUser(args.user_id, args.sys_op_id, args.sys_op_ip, args.punish_id, args.reason)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("punishForbiddenUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_punishForbiddenTaxiUser(self, seqid, iprot, oprot):
    args = punishForbiddenTaxiUser_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = punishForbiddenTaxiUser_result()
    try:
      result.success = self._handler.punishForbiddenTaxiUser(args.user_id, args.sys_op_id, args.sys_op_ip, args.punish_id, args.comment)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("punishForbiddenTaxiUser", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_punishForbiddenTaxiDriver(self, seqid, iprot, oprot):
    args = punishForbiddenTaxiDriver_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = punishForbiddenTaxiDriver_result()
    try:
      result.success = self._handler.punishForbiddenTaxiDriver(args.user_id, args.sys_op_id, args.sys_op_ip, args.punish_id, args.comment)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("punishForbiddenTaxiDriver", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_cutTaxiDriverScore(self, seqid, iprot, oprot):
    args = cutTaxiDriverScore_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = cutTaxiDriverScore_result()
    try:
      result.success = self._handler.cutTaxiDriverScore(args.user_id, args.change_score, args.punish_id, args.punish_type, args.ban_time, args.comment, args.sys_op_id, args.feedback_time, args.feedback_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("cutTaxiDriverScore", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addTaxiDriverScoreHis(self, seqid, iprot, oprot):
    args = addTaxiDriverScoreHis_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addTaxiDriverScoreHis_result()
    try:
      result.success = self._handler.addTaxiDriverScoreHis(args.user_id, args.change_score, args.score_id, args.ban_time, args.punish_id, args.comment, args.recover_time, args.sys_op_id, args.feedback_time, args.feedback_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("addTaxiDriverScoreHis", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkTaxiDriverStatus(self, seqid, iprot, oprot):
    args = checkTaxiDriverStatus_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkTaxiDriverStatus_result()
    try:
      result.success = self._handler.checkTaxiDriverStatus(args.user_id, args.sys_op_id, args.change_score, args.ban_time, args.recover_time)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("checkTaxiDriverStatus", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_punishBanUserSubmitOrder(self, seqid, iprot, oprot):
    args = punishBanUserSubmitOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = punishBanUserSubmitOrder_result()
    try:
      result.success = self._handler.punishBanUserSubmitOrder(args.user_id, args.ban_time, args.punish_id, args.punish_type, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("punishBanUserSubmitOrder", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_resetActionScore(self, seqid, iprot, oprot):
    args = resetActionScore_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = resetActionScore_result()
    try:
      result.success = self._handler.resetActionScore(args.user_id, args.comment, args.sys_op_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("resetActionScore", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getActiveRewardsByCityIdAndDate(self, seqid, iprot, oprot):
    args = getActiveRewardsByCityIdAndDate_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getActiveRewardsByCityIdAndDate_result()
    try:
      result.success = self._handler.getActiveRewardsByCityIdAndDate(args.city_id, args.date)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("getActiveRewardsByCityIdAndDate", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_addWhiteDevice(self, seqid, iprot, oprot):
    args = addWhiteDevice_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = addWhiteDevice_result()
    try:
      result.success = self._handler.addWhiteDevice(args.device)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("addWhiteDevice", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_removeWhiteDevice(self, seqid, iprot, oprot):
    args = removeWhiteDevice_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = removeWhiteDevice_result()
    try:
      result.success = self._handler.removeWhiteDevice(args.device)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("removeWhiteDevice", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_queryWhiteDevice(self, seqid, iprot, oprot):
    args = queryWhiteDevice_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = queryWhiteDevice_result()
    try:
      result.success = self._handler.queryWhiteDevice(args.device)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("queryWhiteDevice", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_recordOrderComplaint(self, seqid, iprot, oprot):
    args = recordOrderComplaint_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = recordOrderComplaint_result()
    try:
      result.success = self._handler.recordOrderComplaint(args.ride_id)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("recordOrderComplaint", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateWithdrawState(self, seqid, iprot, oprot):
    args = updateWithdrawState_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateWithdrawState_result()
    try:
      result.success = self._handler.updateWithdrawState(args.user_id, args.type, args.state, args.remark, args.sys_op_id, args.sys_op_ip)
      msg_type = TMessageType.REPLY
    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
      raise
    except Exception as ex:
      msg_type = TMessageType.EXCEPTION
      logging.exception(ex)
      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
    oprot.writeMessageBegin("updateWithdrawState", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES

class forbiddenUser_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenUser_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDriver_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDriver_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDriver_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDriver_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenDriver_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - group_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.BYTE, 'group_id', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, group_id=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.group_id = group_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BYTE:
          self.group_id = iprot.readByte()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenDriver_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.group_id is not None:
      oprot.writeFieldBegin('group_id', TType.BYTE, 5)
      oprot.writeByte(self.group_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.group_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenDriver_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenDriver_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDevice_args:
  """
  Attributes:
   - device_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'device_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, device_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.device_id = device_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.device_id = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDevice_args')
    if self.device_id is not None:
      oprot.writeFieldBegin('device_id', TType.STRING, 1)
      oprot.writeString(self.device_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.device_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDevice_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (DeviceResult, DeviceResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = DeviceResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDevice_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenDevice_args:
  """
  Attributes:
   - device_id
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'device_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
  )

  def __init__(self, device_id=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.device_id = device_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.device_id = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenDevice_args')
    if self.device_id is not None:
      oprot.writeFieldBegin('device_id', TType.STRING, 1)
      oprot.writeString(self.device_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.device_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenDevice_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (DeviceResult, DeviceResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = DeviceResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenDevice_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenPost_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenPost_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenPost_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenPost_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenPost_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenPost_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenPost_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenPost_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderHold_args:
  """
  Attributes:
   - taxi_order_id
   - holdContent
   - isSend
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'taxi_order_id', None, None, ), # 1
    (2, TType.STRING, 'holdContent', None, None, ), # 2
    (3, TType.BOOL, 'isSend', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
  )

  def __init__(self, taxi_order_id=None, holdContent=None, isSend=None, sys_op_id=None,):
    self.taxi_order_id = taxi_order_id
    self.holdContent = holdContent
    self.isSend = isSend
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.taxi_order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.holdContent = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.BOOL:
          self.isSend = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderHold_args')
    if self.taxi_order_id is not None:
      oprot.writeFieldBegin('taxi_order_id', TType.I64, 1)
      oprot.writeI64(self.taxi_order_id)
      oprot.writeFieldEnd()
    if self.holdContent is not None:
      oprot.writeFieldBegin('holdContent', TType.STRING, 2)
      oprot.writeString(self.holdContent)
      oprot.writeFieldEnd()
    if self.isSend is not None:
      oprot.writeFieldBegin('isSend', TType.BOOL, 3)
      oprot.writeBool(self.isSend)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 4)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.taxi_order_id)
    value = (value * 31) ^ hash(self.holdContent)
    value = (value * 31) ^ hash(self.isSend)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderHold_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderHold_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderCancelHold_args:
  """
  Attributes:
   - taxi_order_id
   - holdContent
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'taxi_order_id', None, None, ), # 1
    (2, TType.STRING, 'holdContent', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
  )

  def __init__(self, taxi_order_id=None, holdContent=None, sys_op_id=None,):
    self.taxi_order_id = taxi_order_id
    self.holdContent = holdContent
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.taxi_order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.holdContent = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderCancelHold_args')
    if self.taxi_order_id is not None:
      oprot.writeFieldBegin('taxi_order_id', TType.I64, 1)
      oprot.writeI64(self.taxi_order_id)
      oprot.writeFieldEnd()
    if self.holdContent is not None:
      oprot.writeFieldBegin('holdContent', TType.STRING, 2)
      oprot.writeString(self.holdContent)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.taxi_order_id)
    value = (value * 31) ^ hash(self.holdContent)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderCancelHold_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderCancelHold_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class orderHold_args:
  """
  Attributes:
   - order_id
   - holdContent
   - isSend
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'order_id', None, None, ), # 1
    (2, TType.STRING, 'holdContent', None, None, ), # 2
    (3, TType.BOOL, 'isSend', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
  )

  def __init__(self, order_id=None, holdContent=None, isSend=None, sys_op_id=None,):
    self.order_id = order_id
    self.holdContent = holdContent
    self.isSend = isSend
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.holdContent = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.BOOL:
          self.isSend = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('orderHold_args')
    if self.order_id is not None:
      oprot.writeFieldBegin('order_id', TType.I64, 1)
      oprot.writeI64(self.order_id)
      oprot.writeFieldEnd()
    if self.holdContent is not None:
      oprot.writeFieldBegin('holdContent', TType.STRING, 2)
      oprot.writeString(self.holdContent)
      oprot.writeFieldEnd()
    if self.isSend is not None:
      oprot.writeFieldBegin('isSend', TType.BOOL, 3)
      oprot.writeBool(self.isSend)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 4)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.order_id)
    value = (value * 31) ^ hash(self.holdContent)
    value = (value * 31) ^ hash(self.isSend)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class orderHold_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('orderHold_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class orderCancelHold_args:
  """
  Attributes:
   - order_id
   - holdContent
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'order_id', None, None, ), # 1
    (2, TType.STRING, 'holdContent', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
  )

  def __init__(self, order_id=None, holdContent=None, sys_op_id=None,):
    self.order_id = order_id
    self.holdContent = holdContent
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.holdContent = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('orderCancelHold_args')
    if self.order_id is not None:
      oprot.writeFieldBegin('order_id', TType.I64, 1)
      oprot.writeI64(self.order_id)
      oprot.writeFieldEnd()
    if self.holdContent is not None:
      oprot.writeFieldBegin('holdContent', TType.STRING, 2)
      oprot.writeString(self.holdContent)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.order_id)
    value = (value * 31) ^ hash(self.holdContent)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class orderCancelHold_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('orderCancelHold_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderSetTag_args:
  """
  Attributes:
   - order_id
   - sys_order_group
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'order_id', None, None, ), # 1
    (2, TType.BYTE, 'sys_order_group', None, None, ), # 2
    (3, TType.STRING, 'reason', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
    (5, TType.STRING, 'sys_op_ip', None, None, ), # 5
  )

  def __init__(self, order_id=None, sys_order_group=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.order_id = order_id
    self.sys_order_group = sys_order_group
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.sys_order_group = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderSetTag_args')
    if self.order_id is not None:
      oprot.writeFieldBegin('order_id', TType.I64, 1)
      oprot.writeI64(self.order_id)
      oprot.writeFieldEnd()
    if self.sys_order_group is not None:
      oprot.writeFieldBegin('sys_order_group', TType.BYTE, 2)
      oprot.writeByte(self.sys_order_group)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 3)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 4)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 5)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.order_id)
    value = (value * 31) ^ hash(self.sys_order_group)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderSetTag_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderSetTag_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class delReply_args:
  """
  Attributes:
   - replyId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'replyId', None, None, ), # 1
  )

  def __init__(self, replyId=None,):
    self.replyId = replyId

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.replyId = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('delReply_args')
    if self.replyId is not None:
      oprot.writeFieldBegin('replyId', TType.STRING, 1)
      oprot.writeString(self.replyId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.replyId)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class delReply_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('delReply_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class delReplyMulti_args:
  """
  Attributes:
   - replyIds
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'replyIds', None, None, ), # 1
  )

  def __init__(self, replyIds=None,):
    self.replyIds = replyIds

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.replyIds = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('delReplyMulti_args')
    if self.replyIds is not None:
      oprot.writeFieldBegin('replyIds', TType.STRING, 1)
      oprot.writeString(self.replyIds)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.replyIds)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class delReplyMulti_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('delReplyMulti_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class maskReply_args:
  """
  Attributes:
   - replyId
   - mask
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'replyId', None, None, ), # 1
    (2, TType.BYTE, 'mask', None, None, ), # 2
  )

  def __init__(self, replyId=None, mask=None,):
    self.replyId = replyId
    self.mask = mask

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.replyId = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.mask = iprot.readByte()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('maskReply_args')
    if self.replyId is not None:
      oprot.writeFieldBegin('replyId', TType.STRING, 1)
      oprot.writeString(self.replyId)
      oprot.writeFieldEnd()
    if self.mask is not None:
      oprot.writeFieldBegin('mask', TType.BYTE, 2)
      oprot.writeByte(self.mask)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.replyId)
    value = (value * 31) ^ hash(self.mask)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class maskReply_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('maskReply_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class maskReplyMulti_args:
  """
  Attributes:
   - replyIds
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'replyIds', None, None, ), # 1
  )

  def __init__(self, replyIds=None,):
    self.replyIds = replyIds

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.replyIds = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('maskReplyMulti_args')
    if self.replyIds is not None:
      oprot.writeFieldBegin('replyIds', TType.STRING, 1)
      oprot.writeString(self.replyIds)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.replyIds)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class maskReplyMulti_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('maskReplyMulti_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenTaxiDriver_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenTaxiDriver_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenTaxiDriver_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenTaxiDriver_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenTaxiDriver_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - group_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.BYTE, 'group_id', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, group_id=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.group_id = group_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BYTE:
          self.group_id = iprot.readByte()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenTaxiDriver_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.group_id is not None:
      oprot.writeFieldBegin('group_id', TType.BYTE, 5)
      oprot.writeByte(self.group_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.group_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenTaxiDriver_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenTaxiDriver_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenTaxiUser_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.I32, 'days', None, None, ), # 5
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenTaxiUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 5)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenTaxiUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenTaxiUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenTaxiUser_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenTaxiUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class unforbiddenTaxiUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('unforbiddenTaxiUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class userOrderSetTag_args:
  """
  Attributes:
   - order_id
   - sys_order_group
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'order_id', None, None, ), # 1
    (2, TType.BYTE, 'sys_order_group', None, None, ), # 2
    (3, TType.STRING, 'reason', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
    (5, TType.STRING, 'sys_op_ip', None, None, ), # 5
  )

  def __init__(self, order_id=None, sys_order_group=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.order_id = order_id
    self.sys_order_group = sys_order_group
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.sys_order_group = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('userOrderSetTag_args')
    if self.order_id is not None:
      oprot.writeFieldBegin('order_id', TType.I64, 1)
      oprot.writeI64(self.order_id)
      oprot.writeFieldEnd()
    if self.sys_order_group is not None:
      oprot.writeFieldBegin('sys_order_group', TType.BYTE, 2)
      oprot.writeByte(self.sys_order_group)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 3)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 4)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 5)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.order_id)
    value = (value * 31) ^ hash(self.sys_order_group)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class userOrderSetTag_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('userOrderSetTag_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createBatch_args:
  """
  Attributes:
   - source
   - type
   - awardTime
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'source', None, None, ), # 1
    (2, TType.STRING, 'type', None, None, ), # 2
    (3, TType.STRING, 'awardTime', None, None, ), # 3
  )

  def __init__(self, source=None, type=None, awardTime=None,):
    self.source = source
    self.type = type
    self.awardTime = awardTime

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.source = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.type = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.awardTime = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createBatch_args')
    if self.source is not None:
      oprot.writeFieldBegin('source', TType.STRING, 1)
      oprot.writeString(self.source)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.STRING, 2)
      oprot.writeString(self.type)
      oprot.writeFieldEnd()
    if self.awardTime is not None:
      oprot.writeFieldBegin('awardTime', TType.STRING, 3)
      oprot.writeString(self.awardTime)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.source)
    value = (value * 31) ^ hash(self.type)
    value = (value * 31) ^ hash(self.awardTime)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class createBatch_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (BatchResult, BatchResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = BatchResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('createBatch_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class insertDetail_args:
  """
  Attributes:
   - batchId
   - userId
   - balance
   - allOrderNum
   - actualOrderNum
   - cityId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'batchId', None, None, ), # 1
    (2, TType.STRING, 'userId', None, None, ), # 2
    (3, TType.STRING, 'balance', None, None, ), # 3
    (4, TType.STRING, 'allOrderNum', None, None, ), # 4
    (5, TType.STRING, 'actualOrderNum', None, None, ), # 5
    (6, TType.STRING, 'cityId', None, None, ), # 6
  )

  def __init__(self, batchId=None, userId=None, balance=None, allOrderNum=None, actualOrderNum=None, cityId=None,):
    self.batchId = batchId
    self.userId = userId
    self.balance = balance
    self.allOrderNum = allOrderNum
    self.actualOrderNum = actualOrderNum
    self.cityId = cityId

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.batchId = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.userId = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.balance = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.allOrderNum = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.actualOrderNum = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.cityId = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('insertDetail_args')
    if self.batchId is not None:
      oprot.writeFieldBegin('batchId', TType.STRING, 1)
      oprot.writeString(self.batchId)
      oprot.writeFieldEnd()
    if self.userId is not None:
      oprot.writeFieldBegin('userId', TType.STRING, 2)
      oprot.writeString(self.userId)
      oprot.writeFieldEnd()
    if self.balance is not None:
      oprot.writeFieldBegin('balance', TType.STRING, 3)
      oprot.writeString(self.balance)
      oprot.writeFieldEnd()
    if self.allOrderNum is not None:
      oprot.writeFieldBegin('allOrderNum', TType.STRING, 4)
      oprot.writeString(self.allOrderNum)
      oprot.writeFieldEnd()
    if self.actualOrderNum is not None:
      oprot.writeFieldBegin('actualOrderNum', TType.STRING, 5)
      oprot.writeString(self.actualOrderNum)
      oprot.writeFieldEnd()
    if self.cityId is not None:
      oprot.writeFieldBegin('cityId', TType.STRING, 6)
      oprot.writeString(self.cityId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.batchId)
    value = (value * 31) ^ hash(self.userId)
    value = (value * 31) ^ hash(self.balance)
    value = (value * 31) ^ hash(self.allOrderNum)
    value = (value * 31) ^ hash(self.actualOrderNum)
    value = (value * 31) ^ hash(self.cityId)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class insertDetail_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (BatchResult, BatchResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = BatchResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('insertDetail_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeBatch_args:
  """
  Attributes:
   - batchId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'batchId', None, None, ), # 1
  )

  def __init__(self, batchId=None,):
    self.batchId = batchId

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.batchId = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeBatch_args')
    if self.batchId is not None:
      oprot.writeFieldBegin('batchId', TType.STRING, 1)
      oprot.writeString(self.batchId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.batchId)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class closeBatch_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (BatchResult, BatchResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = BatchResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('closeBatch_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderSetTagAndDebit_args:
  """
  Attributes:
   - taxi_order_id
   - debitContent
   - sys_op_id
   - debitType
   - debitMoney
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'taxi_order_id', None, None, ), # 1
    (2, TType.STRING, 'debitContent', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.I32, 'debitType', None, None, ), # 4
    (5, TType.STRING, 'debitMoney', None, None, ), # 5
  )

  def __init__(self, taxi_order_id=None, debitContent=None, sys_op_id=None, debitType=None, debitMoney=None,):
    self.taxi_order_id = taxi_order_id
    self.debitContent = debitContent
    self.sys_op_id = sys_op_id
    self.debitType = debitType
    self.debitMoney = debitMoney

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.taxi_order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.debitContent = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.debitType = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.debitMoney = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderSetTagAndDebit_args')
    if self.taxi_order_id is not None:
      oprot.writeFieldBegin('taxi_order_id', TType.I64, 1)
      oprot.writeI64(self.taxi_order_id)
      oprot.writeFieldEnd()
    if self.debitContent is not None:
      oprot.writeFieldBegin('debitContent', TType.STRING, 2)
      oprot.writeString(self.debitContent)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.debitType is not None:
      oprot.writeFieldBegin('debitType', TType.I32, 4)
      oprot.writeI32(self.debitType)
      oprot.writeFieldEnd()
    if self.debitMoney is not None:
      oprot.writeFieldBegin('debitMoney', TType.STRING, 5)
      oprot.writeString(self.debitMoney)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.taxi_order_id)
    value = (value * 31) ^ hash(self.debitContent)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.debitType)
    value = (value * 31) ^ hash(self.debitMoney)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class taxiOrderSetTagAndDebit_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('taxiOrderSetTagAndDebit_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDriverForCms_args:
  """
  Attributes:
   - user_id
   - reason
   - sys_op_id
   - sys_op_ip
   - group_id
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'reason', None, None, ), # 2
    (3, TType.I64, 'sys_op_id', None, None, ), # 3
    (4, TType.STRING, 'sys_op_ip', None, None, ), # 4
    (5, TType.BYTE, 'group_id', None, None, ), # 5
    (6, TType.I32, 'days', None, None, ), # 6
  )

  def __init__(self, user_id=None, reason=None, sys_op_id=None, sys_op_ip=None, group_id=None, days=None,):
    self.user_id = user_id
    self.reason = reason
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.group_id = group_id
    self.days = days

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.sys_op_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BYTE:
          self.group_id = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I32:
          self.days = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDriverForCms_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 2)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I64, 3)
      oprot.writeI64(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 4)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.group_id is not None:
      oprot.writeFieldBegin('group_id', TType.BYTE, 5)
      oprot.writeByte(self.group_id)
      oprot.writeFieldEnd()
    if self.days is not None:
      oprot.writeFieldBegin('days', TType.I32, 6)
      oprot.writeI32(self.days)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.reason)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.group_id)
    value = (value * 31) ^ hash(self.days)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class forbiddenDriverForCms_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('forbiddenDriverForCms_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class saveOrUpdateUserTagCoupon_args:
  """
  Attributes:
   - user_tag
   - coupon_set_ids
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'user_tag', None, None, ), # 1
    (2, TType.LIST, 'coupon_set_ids', (TType.STRING,None), None, ), # 2
  )

  def __init__(self, user_tag=None, coupon_set_ids=None,):
    self.user_tag = user_tag
    self.coupon_set_ids = coupon_set_ids

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.user_tag = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.coupon_set_ids = []
          (_etype3, _size0) = iprot.readListBegin()
          for _i4 in xrange(_size0):
            _elem5 = iprot.readString()
            self.coupon_set_ids.append(_elem5)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('saveOrUpdateUserTagCoupon_args')
    if self.user_tag is not None:
      oprot.writeFieldBegin('user_tag', TType.STRING, 1)
      oprot.writeString(self.user_tag)
      oprot.writeFieldEnd()
    if self.coupon_set_ids is not None:
      oprot.writeFieldBegin('coupon_set_ids', TType.LIST, 2)
      oprot.writeListBegin(TType.STRING, len(self.coupon_set_ids))
      for iter6 in self.coupon_set_ids:
        oprot.writeString(iter6)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_tag)
    value = (value * 31) ^ hash(self.coupon_set_ids)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class saveOrUpdateUserTagCoupon_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('saveOrUpdateUserTagCoupon_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteUserTagCoupon_args:
  """
  Attributes:
   - user_tag
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'user_tag', None, None, ), # 1
  )

  def __init__(self, user_tag=None,):
    self.user_tag = user_tag

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.user_tag = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteUserTagCoupon_args')
    if self.user_tag is not None:
      oprot.writeFieldBegin('user_tag', TType.STRING, 1)
      oprot.writeString(self.user_tag)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_tag)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class deleteUserTagCoupon_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('deleteUserTagCoupon_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTagCouponsByUserTags_args:
  """
  Attributes:
   - user_tags
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'user_tags', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, user_tags=None,):
    self.user_tags = user_tags

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.LIST:
          self.user_tags = []
          (_etype10, _size7) = iprot.readListBegin()
          for _i11 in xrange(_size7):
            _elem12 = iprot.readString()
            self.user_tags.append(_elem12)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTagCouponsByUserTags_args')
    if self.user_tags is not None:
      oprot.writeFieldBegin('user_tags', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.user_tags))
      for iter13 in self.user_tags:
        oprot.writeString(iter13)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_tags)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getTagCouponsByUserTags_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (TagCouponResult, TagCouponResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = TagCouponResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getTagCouponsByUserTags_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenUser_args:
  """
  Attributes:
   - user_id
   - sys_op_id
   - sys_op_ip
   - punish_id
   - reason
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'sys_op_id', None, None, ), # 2
    (3, TType.STRING, 'sys_op_ip', None, None, ), # 3
    (4, TType.I32, 'punish_id', None, None, ), # 4
    (5, TType.STRING, 'reason', None, None, ), # 5
  )

  def __init__(self, user_id=None, sys_op_id=None, sys_op_ip=None, punish_id=None, reason=None,):
    self.user_id = user_id
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.punish_id = punish_id
    self.reason = reason

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.reason = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 2)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 3)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 4)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 5)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.reason)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenTaxiUser_args:
  """
  Attributes:
   - user_id
   - sys_op_id
   - sys_op_ip
   - punish_id
   - comment
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'sys_op_id', None, None, ), # 2
    (3, TType.STRING, 'sys_op_ip', None, None, ), # 3
    (4, TType.I32, 'punish_id', None, None, ), # 4
    (5, TType.STRING, 'comment', None, None, ), # 5
  )

  def __init__(self, user_id=None, sys_op_id=None, sys_op_ip=None, punish_id=None, comment=None,):
    self.user_id = user_id
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.punish_id = punish_id
    self.comment = comment

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.comment = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenTaxiUser_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 2)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 3)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 4)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 5)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.comment)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenTaxiUser_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenTaxiUser_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenTaxiDriver_args:
  """
  Attributes:
   - user_id
   - sys_op_id
   - sys_op_ip
   - punish_id
   - comment
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'sys_op_id', None, None, ), # 2
    (3, TType.STRING, 'sys_op_ip', None, None, ), # 3
    (4, TType.I32, 'punish_id', None, None, ), # 4
    (5, TType.STRING, 'comment', None, None, ), # 5
  )

  def __init__(self, user_id=None, sys_op_id=None, sys_op_ip=None, punish_id=None, comment=None,):
    self.user_id = user_id
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip
    self.punish_id = punish_id
    self.comment = comment

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.comment = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenTaxiDriver_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 2)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 3)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 4)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 5)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.comment)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishForbiddenTaxiDriver_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishForbiddenTaxiDriver_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cutTaxiDriverScore_args:
  """
  Attributes:
   - user_id
   - change_score
   - punish_id
   - punish_type
   - ban_time
   - comment
   - sys_op_id
   - feedback_time
   - feedback_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'change_score', None, None, ), # 2
    (3, TType.I32, 'punish_id', None, None, ), # 3
    (4, TType.STRING, 'punish_type', None, None, ), # 4
    (5, TType.I32, 'ban_time', None, None, ), # 5
    (6, TType.STRING, 'comment', None, None, ), # 6
    (7, TType.I32, 'sys_op_id', None, None, ), # 7
    (8, TType.STRING, 'feedback_time', None, None, ), # 8
    (9, TType.I64, 'feedback_id', None, None, ), # 9
  )

  def __init__(self, user_id=None, change_score=None, punish_id=None, punish_type=None, ban_time=None, comment=None, sys_op_id=None, feedback_time=None, feedback_id=None,):
    self.user_id = user_id
    self.change_score = change_score
    self.punish_id = punish_id
    self.punish_type = punish_type
    self.ban_time = ban_time
    self.comment = comment
    self.sys_op_id = sys_op_id
    self.feedback_time = feedback_time
    self.feedback_id = feedback_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.change_score = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.punish_type = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.ban_time = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.comment = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.STRING:
          self.feedback_time = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 9:
        if ftype == TType.I64:
          self.feedback_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cutTaxiDriverScore_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.change_score is not None:
      oprot.writeFieldBegin('change_score', TType.I32, 2)
      oprot.writeI32(self.change_score)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 3)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.punish_type is not None:
      oprot.writeFieldBegin('punish_type', TType.STRING, 4)
      oprot.writeString(self.punish_type)
      oprot.writeFieldEnd()
    if self.ban_time is not None:
      oprot.writeFieldBegin('ban_time', TType.I32, 5)
      oprot.writeI32(self.ban_time)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 6)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 7)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.feedback_time is not None:
      oprot.writeFieldBegin('feedback_time', TType.STRING, 8)
      oprot.writeString(self.feedback_time)
      oprot.writeFieldEnd()
    if self.feedback_id is not None:
      oprot.writeFieldBegin('feedback_id', TType.I64, 9)
      oprot.writeI64(self.feedback_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.change_score)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.punish_type)
    value = (value * 31) ^ hash(self.ban_time)
    value = (value * 31) ^ hash(self.comment)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.feedback_time)
    value = (value * 31) ^ hash(self.feedback_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class cutTaxiDriverScore_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('cutTaxiDriverScore_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addTaxiDriverScoreHis_args:
  """
  Attributes:
   - user_id
   - change_score
   - score_id
   - ban_time
   - punish_id
   - comment
   - recover_time
   - sys_op_id
   - feedback_time
   - feedback_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'change_score', None, None, ), # 2
    (3, TType.I64, 'score_id', None, None, ), # 3
    (4, TType.I32, 'ban_time', None, None, ), # 4
    (5, TType.I32, 'punish_id', None, None, ), # 5
    (6, TType.STRING, 'comment', None, None, ), # 6
    (7, TType.STRING, 'recover_time', None, None, ), # 7
    (8, TType.I32, 'sys_op_id', None, None, ), # 8
    (9, TType.STRING, 'feedback_time', None, None, ), # 9
    (10, TType.I64, 'feedback_id', None, None, ), # 10
  )

  def __init__(self, user_id=None, change_score=None, score_id=None, ban_time=None, punish_id=None, comment=None, recover_time=None, sys_op_id=None, feedback_time=None, feedback_id=None,):
    self.user_id = user_id
    self.change_score = change_score
    self.score_id = score_id
    self.ban_time = ban_time
    self.punish_id = punish_id
    self.comment = comment
    self.recover_time = recover_time
    self.sys_op_id = sys_op_id
    self.feedback_time = feedback_time
    self.feedback_id = feedback_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.change_score = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.score_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.ban_time = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.comment = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.STRING:
          self.recover_time = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 9:
        if ftype == TType.STRING:
          self.feedback_time = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 10:
        if ftype == TType.I64:
          self.feedback_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addTaxiDriverScoreHis_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.change_score is not None:
      oprot.writeFieldBegin('change_score', TType.I32, 2)
      oprot.writeI32(self.change_score)
      oprot.writeFieldEnd()
    if self.score_id is not None:
      oprot.writeFieldBegin('score_id', TType.I64, 3)
      oprot.writeI64(self.score_id)
      oprot.writeFieldEnd()
    if self.ban_time is not None:
      oprot.writeFieldBegin('ban_time', TType.I32, 4)
      oprot.writeI32(self.ban_time)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 5)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 6)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    if self.recover_time is not None:
      oprot.writeFieldBegin('recover_time', TType.STRING, 7)
      oprot.writeString(self.recover_time)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 8)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.feedback_time is not None:
      oprot.writeFieldBegin('feedback_time', TType.STRING, 9)
      oprot.writeString(self.feedback_time)
      oprot.writeFieldEnd()
    if self.feedback_id is not None:
      oprot.writeFieldBegin('feedback_id', TType.I64, 10)
      oprot.writeI64(self.feedback_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.change_score)
    value = (value * 31) ^ hash(self.score_id)
    value = (value * 31) ^ hash(self.ban_time)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.comment)
    value = (value * 31) ^ hash(self.recover_time)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.feedback_time)
    value = (value * 31) ^ hash(self.feedback_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addTaxiDriverScoreHis_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addTaxiDriverScoreHis_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class checkTaxiDriverStatus_args:
  """
  Attributes:
   - user_id
   - sys_op_id
   - change_score
   - ban_time
   - recover_time
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'sys_op_id', None, None, ), # 2
    (3, TType.I32, 'change_score', None, None, ), # 3
    (4, TType.I32, 'ban_time', None, None, ), # 4
    (5, TType.STRING, 'recover_time', None, None, ), # 5
  )

  def __init__(self, user_id=None, sys_op_id=None, change_score=None, ban_time=None, recover_time=None,):
    self.user_id = user_id
    self.sys_op_id = sys_op_id
    self.change_score = change_score
    self.ban_time = ban_time
    self.recover_time = recover_time

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.change_score = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.ban_time = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.recover_time = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('checkTaxiDriverStatus_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 2)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.change_score is not None:
      oprot.writeFieldBegin('change_score', TType.I32, 3)
      oprot.writeI32(self.change_score)
      oprot.writeFieldEnd()
    if self.ban_time is not None:
      oprot.writeFieldBegin('ban_time', TType.I32, 4)
      oprot.writeI32(self.ban_time)
      oprot.writeFieldEnd()
    if self.recover_time is not None:
      oprot.writeFieldBegin('recover_time', TType.STRING, 5)
      oprot.writeString(self.recover_time)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.change_score)
    value = (value * 31) ^ hash(self.ban_time)
    value = (value * 31) ^ hash(self.recover_time)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class checkTaxiDriverStatus_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('checkTaxiDriverStatus_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishBanUserSubmitOrder_args:
  """
  Attributes:
   - user_id
   - ban_time
   - punish_id
   - punish_type
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.I32, 'ban_time', None, None, ), # 2
    (3, TType.I32, 'punish_id', None, None, ), # 3
    (4, TType.STRING, 'punish_type', None, None, ), # 4
    (5, TType.I32, 'sys_op_id', None, None, ), # 5
  )

  def __init__(self, user_id=None, ban_time=None, punish_id=None, punish_type=None, sys_op_id=None,):
    self.user_id = user_id
    self.ban_time = ban_time
    self.punish_id = punish_id
    self.punish_type = punish_type
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.ban_time = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.punish_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.punish_type = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishBanUserSubmitOrder_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.ban_time is not None:
      oprot.writeFieldBegin('ban_time', TType.I32, 2)
      oprot.writeI32(self.ban_time)
      oprot.writeFieldEnd()
    if self.punish_id is not None:
      oprot.writeFieldBegin('punish_id', TType.I32, 3)
      oprot.writeI32(self.punish_id)
      oprot.writeFieldEnd()
    if self.punish_type is not None:
      oprot.writeFieldBegin('punish_type', TType.STRING, 4)
      oprot.writeString(self.punish_type)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 5)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.ban_time)
    value = (value * 31) ^ hash(self.punish_id)
    value = (value * 31) ^ hash(self.punish_type)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class punishBanUserSubmitOrder_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('punishBanUserSubmitOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class resetActionScore_args:
  """
  Attributes:
   - user_id
   - comment
   - sys_op_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'comment', None, None, ), # 2
    (3, TType.I32, 'sys_op_id', None, None, ), # 3
  )

  def __init__(self, user_id=None, comment=None, sys_op_id=None,):
    self.user_id = user_id
    self.comment = comment
    self.sys_op_id = sys_op_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.comment = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('resetActionScore_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 2)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 3)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.comment)
    value = (value * 31) ^ hash(self.sys_op_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class resetActionScore_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('resetActionScore_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveRewardsByCityIdAndDate_args:
  """
  Attributes:
   - city_id
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'city_id', None, None, ), # 1
    (2, TType.STRING, 'date', None, None, ), # 2
  )

  def __init__(self, city_id=None, date=None,):
    self.city_id = city_id
    self.date = date

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.city_id = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.date = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveRewardsByCityIdAndDate_args')
    if self.city_id is not None:
      oprot.writeFieldBegin('city_id', TType.STRING, 1)
      oprot.writeString(self.city_id)
      oprot.writeFieldEnd()
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.STRING, 2)
      oprot.writeString(self.date)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.city_id)
    value = (value * 31) ^ hash(self.date)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class getActiveRewardsByCityIdAndDate_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (DataResult, DataResult.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = DataResult()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('getActiveRewardsByCityIdAndDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addWhiteDevice_args:
  """
  Attributes:
   - device
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'device', None, None, ), # 1
  )

  def __init__(self, device=None,):
    self.device = device

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.device = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addWhiteDevice_args')
    if self.device is not None:
      oprot.writeFieldBegin('device', TType.STRING, 1)
      oprot.writeString(self.device)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.device)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class addWhiteDevice_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('addWhiteDevice_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeWhiteDevice_args:
  """
  Attributes:
   - device
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'device', None, None, ), # 1
  )

  def __init__(self, device=None,):
    self.device = device

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.device = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeWhiteDevice_args')
    if self.device is not None:
      oprot.writeFieldBegin('device', TType.STRING, 1)
      oprot.writeString(self.device)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.device)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class removeWhiteDevice_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('removeWhiteDevice_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class queryWhiteDevice_args:
  """
  Attributes:
   - device
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'device', None, None, ), # 1
  )

  def __init__(self, device=None,):
    self.device = device

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.device = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('queryWhiteDevice_args')
    if self.device is not None:
      oprot.writeFieldBegin('device', TType.STRING, 1)
      oprot.writeString(self.device)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.device)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class queryWhiteDevice_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('queryWhiteDevice_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class recordOrderComplaint_args:
  """
  Attributes:
   - ride_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'ride_id', None, None, ), # 1
  )

  def __init__(self, ride_id=None,):
    self.ride_id = ride_id

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.ride_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('recordOrderComplaint_args')
    if self.ride_id is not None:
      oprot.writeFieldBegin('ride_id', TType.I64, 1)
      oprot.writeI64(self.ride_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.ride_id)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class recordOrderComplaint_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('recordOrderComplaint_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class updateWithdrawState_args:
  """
  Attributes:
   - user_id
   - type
   - state
   - remark
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'user_id', None, None, ), # 1
    (2, TType.STRING, 'type', None, None, ), # 2
    (3, TType.BYTE, 'state', None, None, ), # 3
    (4, TType.STRING, 'remark', None, None, ), # 4
    (5, TType.I32, 'sys_op_id', None, None, ), # 5
    (6, TType.STRING, 'sys_op_ip', None, None, ), # 6
  )

  def __init__(self, user_id=None, type=None, state=None, remark=None, sys_op_id=None, sys_op_ip=None,):
    self.user_id = user_id
    self.type = type
    self.state = state
    self.remark = remark
    self.sys_op_id = sys_op_id
    self.sys_op_ip = sys_op_ip

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.user_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.type = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.BYTE:
          self.state = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.remark = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.sys_op_id = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.sys_op_ip = iprot.readString()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('updateWithdrawState_args')
    if self.user_id is not None:
      oprot.writeFieldBegin('user_id', TType.I64, 1)
      oprot.writeI64(self.user_id)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.STRING, 2)
      oprot.writeString(self.type)
      oprot.writeFieldEnd()
    if self.state is not None:
      oprot.writeFieldBegin('state', TType.BYTE, 3)
      oprot.writeByte(self.state)
      oprot.writeFieldEnd()
    if self.remark is not None:
      oprot.writeFieldBegin('remark', TType.STRING, 4)
      oprot.writeString(self.remark)
      oprot.writeFieldEnd()
    if self.sys_op_id is not None:
      oprot.writeFieldBegin('sys_op_id', TType.I32, 5)
      oprot.writeI32(self.sys_op_id)
      oprot.writeFieldEnd()
    if self.sys_op_ip is not None:
      oprot.writeFieldBegin('sys_op_ip', TType.STRING, 6)
      oprot.writeString(self.sys_op_ip)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.user_id)
    value = (value * 31) ^ hash(self.type)
    value = (value * 31) ^ hash(self.state)
    value = (value * 31) ^ hash(self.remark)
    value = (value * 31) ^ hash(self.sys_op_id)
    value = (value * 31) ^ hash(self.sys_op_ip)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class updateWithdrawState_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (Result, Result.thrift_spec), None, ), # 0
  )

  def __init__(self, success=None,):
    self.success = success

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 0:
        if ftype == TType.STRUCT:
          self.success = Result()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('updateWithdrawState_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.success)
    return value

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)
