#
# 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 holdOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    pass

  def cancelHoldOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    pass

  def holdTaxiOrder(self, OrderId, sysOpId, content, isSend):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
     - isSend
    """
    pass

  def cancelHoldTaxiOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    pass

  def forbiddenUser(self, userId, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    pass

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

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

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

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

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

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

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

  def taxiOrderSetTag(self, taxi_order_id, group_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - taxi_order_id
     - group_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    pass

  def delPost(self, postId):
    """
    Parameters:
     - postId
    """
    pass

  def delPostMulti(self, postIds):
    """
    Parameters:
     - postIds
    """
    pass

  def delUserAllPost(self, userId):
    """
    Parameters:
     - userId
    """
    pass

  def maskPost(self, postId, mask, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - postId
     - mask
     - comment
     - sys_op_id
     - sys_op_ip
    """
    pass

  def maskPostMulti(self, postId, mask, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - postId
     - mask
     - comment
     - sys_op_id
     - sys_op_ip
    """
    pass

  def maskUserAllPost(self, userId, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - userId
     - comment
     - 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 holdOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    self.send_holdOrder(OrderId, sysOpId, content)
    self.recv_holdOrder()

  def send_holdOrder(self, OrderId, sysOpId, content):
    self._oprot.writeMessageBegin('holdOrder', TMessageType.CALL, self._seqid)
    args = holdOrder_args()
    args.OrderId = OrderId
    args.sysOpId = sysOpId
    args.content = content
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_holdOrder(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = holdOrder_result()
    result.read(iprot)
    iprot.readMessageEnd()
    return

  def cancelHoldOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    self.send_cancelHoldOrder(OrderId, sysOpId, content)
    self.recv_cancelHoldOrder()

  def send_cancelHoldOrder(self, OrderId, sysOpId, content):
    self._oprot.writeMessageBegin('cancelHoldOrder', TMessageType.CALL, self._seqid)
    args = cancelHoldOrder_args()
    args.OrderId = OrderId
    args.sysOpId = sysOpId
    args.content = content
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_cancelHoldOrder(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = cancelHoldOrder_result()
    result.read(iprot)
    iprot.readMessageEnd()
    return

  def holdTaxiOrder(self, OrderId, sysOpId, content, isSend):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
     - isSend
    """
    self.send_holdTaxiOrder(OrderId, sysOpId, content, isSend)
    return self.recv_holdTaxiOrder()

  def send_holdTaxiOrder(self, OrderId, sysOpId, content, isSend):
    self._oprot.writeMessageBegin('holdTaxiOrder', TMessageType.CALL, self._seqid)
    args = holdTaxiOrder_args()
    args.OrderId = OrderId
    args.sysOpId = sysOpId
    args.content = content
    args.isSend = isSend
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

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

  def cancelHoldTaxiOrder(self, OrderId, sysOpId, content):
    """
    Parameters:
     - OrderId
     - sysOpId
     - content
    """
    self.send_cancelHoldTaxiOrder(OrderId, sysOpId, content)
    return self.recv_cancelHoldTaxiOrder()

  def send_cancelHoldTaxiOrder(self, OrderId, sysOpId, content):
    self._oprot.writeMessageBegin('cancelHoldTaxiOrder', TMessageType.CALL, self._seqid)
    args = cancelHoldTaxiOrder_args()
    args.OrderId = OrderId
    args.sysOpId = sysOpId
    args.content = content
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

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

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

  def send_forbiddenUser(self, userId, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenUser', TMessageType.CALL, self._seqid)
    args = forbiddenUser_args()
    args.userId = userId
    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, userId, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenUser(userId, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenUser()

  def send_unforbiddenUser(self, userId, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenUser', TMessageType.CALL, self._seqid)
    args = unforbiddenUser_args()
    args.userId = userId
    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, userId, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenDriver(userId, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenDriver()

  def send_forbiddenDriver(self, userId, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenDriver', TMessageType.CALL, self._seqid)
    args = forbiddenDriver_args()
    args.userId = userId
    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, userId, reason, sys_op_id, sys_op_ip, group_id):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
     - group_id
    """
    self.send_unforbiddenDriver(userId, reason, sys_op_id, sys_op_ip, group_id)
    return self.recv_unforbiddenDriver()

  def send_unforbiddenDriver(self, userId, reason, sys_op_id, sys_op_ip, group_id):
    self._oprot.writeMessageBegin('unforbiddenDriver', TMessageType.CALL, self._seqid)
    args = unforbiddenDriver_args()
    args.userId = userId
    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, deviceId, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - deviceId
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenDevice(deviceId, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenDevice()

  def send_forbiddenDevice(self, deviceId, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenDevice', TMessageType.CALL, self._seqid)
    args = forbiddenDevice_args()
    args.deviceId = deviceId
    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, deviceId, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - deviceId
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenDevice(deviceId, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenDevice()

  def send_unforbiddenDevice(self, deviceId, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenDevice', TMessageType.CALL, self._seqid)
    args = unforbiddenDevice_args()
    args.deviceId = deviceId
    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, userId, reason, sys_op_id, sys_op_ip, days):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
     - days
    """
    self.send_forbiddenPost(userId, reason, sys_op_id, sys_op_ip, days)
    return self.recv_forbiddenPost()

  def send_forbiddenPost(self, userId, reason, sys_op_id, sys_op_ip, days):
    self._oprot.writeMessageBegin('forbiddenPost', TMessageType.CALL, self._seqid)
    args = forbiddenPost_args()
    args.userId = userId
    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, userId, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - userId
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_unforbiddenPost(userId, reason, sys_op_id, sys_op_ip)
    return self.recv_unforbiddenPost()

  def send_unforbiddenPost(self, userId, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('unforbiddenPost', TMessageType.CALL, self._seqid)
    args = unforbiddenPost_args()
    args.userId = userId
    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 taxiOrderSetTag(self, taxi_order_id, group_id, reason, sys_op_id, sys_op_ip):
    """
    Parameters:
     - taxi_order_id
     - group_id
     - reason
     - sys_op_id
     - sys_op_ip
    """
    self.send_taxiOrderSetTag(taxi_order_id, group_id, reason, sys_op_id, sys_op_ip)
    return self.recv_taxiOrderSetTag()

  def send_taxiOrderSetTag(self, taxi_order_id, group_id, reason, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('taxiOrderSetTag', TMessageType.CALL, self._seqid)
    args = taxiOrderSetTag_args()
    args.taxi_order_id = taxi_order_id
    args.group_id = group_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_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 delPost(self, postId):
    """
    Parameters:
     - postId
    """
    self.send_delPost(postId)
    return self.recv_delPost()

  def send_delPost(self, postId):
    self._oprot.writeMessageBegin('delPost', TMessageType.CALL, self._seqid)
    args = delPost_args()
    args.postId = postId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

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

  def delPostMulti(self, postIds):
    """
    Parameters:
     - postIds
    """
    self.send_delPostMulti(postIds)
    return self.recv_delPostMulti()

  def send_delPostMulti(self, postIds):
    self._oprot.writeMessageBegin('delPostMulti', TMessageType.CALL, self._seqid)
    args = delPostMulti_args()
    args.postIds = postIds
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

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

  def delUserAllPost(self, userId):
    """
    Parameters:
     - userId
    """
    self.send_delUserAllPost(userId)
    return self.recv_delUserAllPost()

  def send_delUserAllPost(self, userId):
    self._oprot.writeMessageBegin('delUserAllPost', TMessageType.CALL, self._seqid)
    args = delUserAllPost_args()
    args.userId = userId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

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

  def maskPost(self, postId, mask, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - postId
     - mask
     - comment
     - sys_op_id
     - sys_op_ip
    """
    self.send_maskPost(postId, mask, comment, sys_op_id, sys_op_ip)
    return self.recv_maskPost()

  def send_maskPost(self, postId, mask, comment, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('maskPost', TMessageType.CALL, self._seqid)
    args = maskPost_args()
    args.postId = postId
    args.mask = mask
    args.comment = comment
    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_maskPost(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = maskPost_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "maskPost failed: unknown result")

  def maskPostMulti(self, postId, mask, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - postId
     - mask
     - comment
     - sys_op_id
     - sys_op_ip
    """
    self.send_maskPostMulti(postId, mask, comment, sys_op_id, sys_op_ip)
    return self.recv_maskPostMulti()

  def send_maskPostMulti(self, postId, mask, comment, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('maskPostMulti', TMessageType.CALL, self._seqid)
    args = maskPostMulti_args()
    args.postId = postId
    args.mask = mask
    args.comment = comment
    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_maskPostMulti(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = maskPostMulti_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "maskPostMulti failed: unknown result")

  def maskUserAllPost(self, userId, comment, sys_op_id, sys_op_ip):
    """
    Parameters:
     - userId
     - comment
     - sys_op_id
     - sys_op_ip
    """
    self.send_maskUserAllPost(userId, comment, sys_op_id, sys_op_ip)
    return self.recv_maskUserAllPost()

  def send_maskUserAllPost(self, userId, comment, sys_op_id, sys_op_ip):
    self._oprot.writeMessageBegin('maskUserAllPost', TMessageType.CALL, self._seqid)
    args = maskUserAllPost_args()
    args.userId = userId
    args.comment = comment
    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_maskUserAllPost(self):
    iprot = self._iprot
    (fname, mtype, rseqid) = iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(iprot)
      iprot.readMessageEnd()
      raise x
    result = maskUserAllPost_result()
    result.read(iprot)
    iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "maskUserAllPost failed: unknown result")


class Processor(Iface, TProcessor):
  def __init__(self, handler):
    self._handler = handler
    self._processMap = {}
    self._processMap["holdOrder"] = Processor.process_holdOrder
    self._processMap["cancelHoldOrder"] = Processor.process_cancelHoldOrder
    self._processMap["holdTaxiOrder"] = Processor.process_holdTaxiOrder
    self._processMap["cancelHoldTaxiOrder"] = Processor.process_cancelHoldTaxiOrder
    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["taxiOrderSetTag"] = Processor.process_taxiOrderSetTag
    self._processMap["delPost"] = Processor.process_delPost
    self._processMap["delPostMulti"] = Processor.process_delPostMulti
    self._processMap["delUserAllPost"] = Processor.process_delUserAllPost
    self._processMap["maskPost"] = Processor.process_maskPost
    self._processMap["maskPostMulti"] = Processor.process_maskPostMulti
    self._processMap["maskUserAllPost"] = Processor.process_maskUserAllPost

  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_holdOrder(self, seqid, iprot, oprot):
    args = holdOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = holdOrder_result()
    try:
      self._handler.holdOrder(args.OrderId, args.sysOpId, args.content)
      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("holdOrder", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_cancelHoldOrder(self, seqid, iprot, oprot):
    args = cancelHoldOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = cancelHoldOrder_result()
    try:
      self._handler.cancelHoldOrder(args.OrderId, args.sysOpId, args.content)
      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("cancelHoldOrder", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_holdTaxiOrder(self, seqid, iprot, oprot):
    args = holdTaxiOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = holdTaxiOrder_result()
    try:
      result.success = self._handler.holdTaxiOrder(args.OrderId, args.sysOpId, args.content, args.isSend)
      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("holdTaxiOrder", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_cancelHoldTaxiOrder(self, seqid, iprot, oprot):
    args = cancelHoldTaxiOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = cancelHoldTaxiOrder_result()
    try:
      result.success = self._handler.cancelHoldTaxiOrder(args.OrderId, args.sysOpId, args.content)
      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("cancelHoldTaxiOrder", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  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.userId, 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.userId, 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.userId, 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.userId, 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.deviceId, 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.deviceId, 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.userId, 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.userId, 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_taxiOrderSetTag(self, seqid, iprot, oprot):
    args = taxiOrderSetTag_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = taxiOrderSetTag_result()
    try:
      result.success = self._handler.taxiOrderSetTag(args.taxi_order_id, args.group_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("taxiOrderSetTag", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_delPost(self, seqid, iprot, oprot):
    args = delPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = delPost_result()
    try:
      result.success = self._handler.delPost(args.postId)
      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("delPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_delPostMulti(self, seqid, iprot, oprot):
    args = delPostMulti_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = delPostMulti_result()
    try:
      result.success = self._handler.delPostMulti(args.postIds)
      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("delPostMulti", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_delUserAllPost(self, seqid, iprot, oprot):
    args = delUserAllPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = delUserAllPost_result()
    try:
      result.success = self._handler.delUserAllPost(args.userId)
      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("delUserAllPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_maskPost(self, seqid, iprot, oprot):
    args = maskPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = maskPost_result()
    try:
      result.success = self._handler.maskPost(args.postId, args.mask, args.comment, 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("maskPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_maskPostMulti(self, seqid, iprot, oprot):
    args = maskPostMulti_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = maskPostMulti_result()
    try:
      result.success = self._handler.maskPostMulti(args.postId, args.mask, args.comment, 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("maskPostMulti", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_maskUserAllPost(self, seqid, iprot, oprot):
    args = maskUserAllPost_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = maskUserAllPost_result()
    try:
      result.success = self._handler.maskUserAllPost(args.userId, args.comment, 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("maskUserAllPost", msg_type, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES

class holdOrder_args:
  """
  Attributes:
   - OrderId
   - sysOpId
   - content
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'OrderId', None, None, ), # 1
    (2, TType.I32, 'sysOpId', None, None, ), # 2
    (3, TType.STRING, 'content', None, None, ), # 3
  )

  def __init__(self, OrderId=None, sysOpId=None, content=None,):
    self.OrderId = OrderId
    self.sysOpId = sysOpId
    self.content = content

  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.OrderId = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sysOpId = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.content = 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('holdOrder_args')
    if self.OrderId is not None:
      oprot.writeFieldBegin('OrderId', TType.I64, 1)
      oprot.writeI64(self.OrderId)
      oprot.writeFieldEnd()
    if self.sysOpId is not None:
      oprot.writeFieldBegin('sysOpId', TType.I32, 2)
      oprot.writeI32(self.sysOpId)
      oprot.writeFieldEnd()
    if self.content is not None:
      oprot.writeFieldBegin('content', TType.STRING, 3)
      oprot.writeString(self.content)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.OrderId)
    value = (value * 31) ^ hash(self.sysOpId)
    value = (value * 31) ^ hash(self.content)
    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 holdOrder_result:

  thrift_spec = (
  )

  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
      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('holdOrder_result')
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    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 cancelHoldOrder_args:
  """
  Attributes:
   - OrderId
   - sysOpId
   - content
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'OrderId', None, None, ), # 1
    (2, TType.I32, 'sysOpId', None, None, ), # 2
    (3, TType.STRING, 'content', None, None, ), # 3
  )

  def __init__(self, OrderId=None, sysOpId=None, content=None,):
    self.OrderId = OrderId
    self.sysOpId = sysOpId
    self.content = content

  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.OrderId = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sysOpId = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.content = 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('cancelHoldOrder_args')
    if self.OrderId is not None:
      oprot.writeFieldBegin('OrderId', TType.I64, 1)
      oprot.writeI64(self.OrderId)
      oprot.writeFieldEnd()
    if self.sysOpId is not None:
      oprot.writeFieldBegin('sysOpId', TType.I32, 2)
      oprot.writeI32(self.sysOpId)
      oprot.writeFieldEnd()
    if self.content is not None:
      oprot.writeFieldBegin('content', TType.STRING, 3)
      oprot.writeString(self.content)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.OrderId)
    value = (value * 31) ^ hash(self.sysOpId)
    value = (value * 31) ^ hash(self.content)
    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 cancelHoldOrder_result:

  thrift_spec = (
  )

  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
      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('cancelHoldOrder_result')
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    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 holdTaxiOrder_args:
  """
  Attributes:
   - OrderId
   - sysOpId
   - content
   - isSend
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'OrderId', None, None, ), # 1
    (2, TType.I32, 'sysOpId', None, None, ), # 2
    (3, TType.STRING, 'content', None, None, ), # 3
    (4, TType.BOOL, 'isSend', None, None, ), # 4
  )

  def __init__(self, OrderId=None, sysOpId=None, content=None, isSend=None,):
    self.OrderId = OrderId
    self.sysOpId = sysOpId
    self.content = content
    self.isSend = isSend

  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.OrderId = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sysOpId = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.content = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.BOOL:
          self.isSend = iprot.readBool()
        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('holdTaxiOrder_args')
    if self.OrderId is not None:
      oprot.writeFieldBegin('OrderId', TType.I64, 1)
      oprot.writeI64(self.OrderId)
      oprot.writeFieldEnd()
    if self.sysOpId is not None:
      oprot.writeFieldBegin('sysOpId', TType.I32, 2)
      oprot.writeI32(self.sysOpId)
      oprot.writeFieldEnd()
    if self.content is not None:
      oprot.writeFieldBegin('content', TType.STRING, 3)
      oprot.writeString(self.content)
      oprot.writeFieldEnd()
    if self.isSend is not None:
      oprot.writeFieldBegin('isSend', TType.BOOL, 4)
      oprot.writeBool(self.isSend)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.OrderId)
    value = (value * 31) ^ hash(self.sysOpId)
    value = (value * 31) ^ hash(self.content)
    value = (value * 31) ^ hash(self.isSend)
    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 holdTaxiOrder_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('holdTaxiOrder_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 cancelHoldTaxiOrder_args:
  """
  Attributes:
   - OrderId
   - sysOpId
   - content
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'OrderId', None, None, ), # 1
    (2, TType.I32, 'sysOpId', None, None, ), # 2
    (3, TType.STRING, 'content', None, None, ), # 3
  )

  def __init__(self, OrderId=None, sysOpId=None, content=None,):
    self.OrderId = OrderId
    self.sysOpId = sysOpId
    self.content = content

  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.OrderId = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.sysOpId = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.content = 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('cancelHoldTaxiOrder_args')
    if self.OrderId is not None:
      oprot.writeFieldBegin('OrderId', TType.I64, 1)
      oprot.writeI64(self.OrderId)
      oprot.writeFieldEnd()
    if self.sysOpId is not None:
      oprot.writeFieldBegin('sysOpId', TType.I32, 2)
      oprot.writeI32(self.sysOpId)
      oprot.writeFieldEnd()
    if self.content is not None:
      oprot.writeFieldBegin('content', TType.STRING, 3)
      oprot.writeString(self.content)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.OrderId)
    value = (value * 31) ^ hash(self.sysOpId)
    value = (value * 31) ^ hash(self.content)
    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 cancelHoldTaxiOrder_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('cancelHoldTaxiOrder_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 forbiddenUser_args:
  """
  Attributes:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
   - group_id
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None, group_id=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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:
   - deviceId
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'deviceId', 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, deviceId=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.deviceId = deviceId
    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.deviceId = 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.deviceId is not None:
      oprot.writeFieldBegin('deviceId', TType.STRING, 1)
      oprot.writeString(self.deviceId)
      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.deviceId)
    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:
   - deviceId
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'deviceId', 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, deviceId=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.deviceId = deviceId
    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.deviceId = 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.deviceId is not None:
      oprot.writeFieldBegin('deviceId', TType.STRING, 1)
      oprot.writeString(self.deviceId)
      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.deviceId)
    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:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
   - days
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None, days=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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:
   - userId
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', 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, userId=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.userId = userId
    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.userId = 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.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.userId)
    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 taxiOrderSetTag_args:
  """
  Attributes:
   - taxi_order_id
   - group_id
   - reason
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'taxi_order_id', None, None, ), # 1
    (2, TType.BYTE, 'group_id', 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, taxi_order_id=None, group_id=None, reason=None, sys_op_id=None, sys_op_ip=None,):
    self.taxi_order_id = taxi_order_id
    self.group_id = group_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.taxi_order_id = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.group_id = 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.taxi_order_id is not None:
      oprot.writeFieldBegin('taxi_order_id', TType.I64, 1)
      oprot.writeI64(self.taxi_order_id)
      oprot.writeFieldEnd()
    if self.group_id is not None:
      oprot.writeFieldBegin('group_id', TType.BYTE, 2)
      oprot.writeByte(self.group_id)
      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.taxi_order_id)
    value = (value * 31) ^ hash(self.group_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 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 delPost_args:
  """
  Attributes:
   - postId
  """

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

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

  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.postId = 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('delPost_args')
    if self.postId is not None:
      oprot.writeFieldBegin('postId', TType.STRING, 1)
      oprot.writeString(self.postId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.postId)
    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 delPost_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('delPost_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 delPostMulti_args:
  """
  Attributes:
   - postIds
  """

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

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

  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.postIds = []
          (_etype10, _size7) = iprot.readListBegin()
          for _i11 in xrange(_size7):
            _elem12 = iprot.readString()
            self.postIds.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('delPostMulti_args')
    if self.postIds is not None:
      oprot.writeFieldBegin('postIds', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.postIds))
      for iter13 in self.postIds:
        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.postIds)
    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 delPostMulti_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (MultiPostResult, MultiPostResult.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 = MultiPostResult()
          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('delPostMulti_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 delUserAllPost_args:
  """
  Attributes:
   - userId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'userId', None, None, ), # 1
  )

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

  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.userId = 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('delUserAllPost_args')
    if self.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return


  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.userId)
    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 delUserAllPost_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('delUserAllPost_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 maskPost_args:
  """
  Attributes:
   - postId
   - mask
   - comment
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'postId', None, None, ), # 1
    (2, TType.BYTE, 'mask', None, None, ), # 2
    (3, TType.STRING, 'comment', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
    (5, TType.STRING, 'sys_op_ip', None, None, ), # 5
  )

  def __init__(self, postId=None, mask=None, comment=None, sys_op_id=None, sys_op_ip=None,):
    self.postId = postId
    self.mask = mask
    self.comment = comment
    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.postId = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.mask = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.comment = 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('maskPost_args')
    if self.postId is not None:
      oprot.writeFieldBegin('postId', TType.STRING, 1)
      oprot.writeString(self.postId)
      oprot.writeFieldEnd()
    if self.mask is not None:
      oprot.writeFieldBegin('mask', TType.BYTE, 2)
      oprot.writeByte(self.mask)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 3)
      oprot.writeString(self.comment)
      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.postId)
    value = (value * 31) ^ hash(self.mask)
    value = (value * 31) ^ hash(self.comment)
    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 maskPost_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('maskPost_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 maskPostMulti_args:
  """
  Attributes:
   - postId
   - mask
   - comment
   - sys_op_id
   - sys_op_ip
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'postId', (TType.STRING,None), None, ), # 1
    (2, TType.BYTE, 'mask', None, None, ), # 2
    (3, TType.STRING, 'comment', None, None, ), # 3
    (4, TType.I64, 'sys_op_id', None, None, ), # 4
    (5, TType.STRING, 'sys_op_ip', None, None, ), # 5
  )

  def __init__(self, postId=None, mask=None, comment=None, sys_op_id=None, sys_op_ip=None,):
    self.postId = postId
    self.mask = mask
    self.comment = comment
    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.LIST:
          self.postId = []
          (_etype17, _size14) = iprot.readListBegin()
          for _i18 in xrange(_size14):
            _elem19 = iprot.readString()
            self.postId.append(_elem19)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BYTE:
          self.mask = iprot.readByte()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.comment = 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('maskPostMulti_args')
    if self.postId is not None:
      oprot.writeFieldBegin('postId', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.postId))
      for iter20 in self.postId:
        oprot.writeString(iter20)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.mask is not None:
      oprot.writeFieldBegin('mask', TType.BYTE, 2)
      oprot.writeByte(self.mask)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 3)
      oprot.writeString(self.comment)
      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.postId)
    value = (value * 31) ^ hash(self.mask)
    value = (value * 31) ^ hash(self.comment)
    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 maskPostMulti_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (MultiPostResult, MultiPostResult.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 = MultiPostResult()
          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('maskPostMulti_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 maskUserAllPost_args:
  """
  Attributes:
   - userId
   - comment
   - sys_op_id
   - sys_op_ip
  """

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

  def __init__(self, userId=None, comment=None, sys_op_id=None, sys_op_ip=None,):
    self.userId = userId
    self.comment = comment
    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.userId = 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.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('maskUserAllPost_args')
    if self.userId is not None:
      oprot.writeFieldBegin('userId', TType.I64, 1)
      oprot.writeI64(self.userId)
      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.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.userId)
    value = (value * 31) ^ hash(self.comment)
    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 maskUserAllPost_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('maskUserAllPost_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)
