SimEvents.ice.C

// **********************************************************************
//
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `SimEvents.ice'

#include <SimEvents.ice.H>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

static const ::std::string __SimEvents__Events__evolve_name = "evolve";

::Ice::Object* IceInternal::upCast(::SimEvents::EventMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::EventMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::Events* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::Events* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::RetinaMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::RetinaMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::VisualCortexMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::VisualCortexMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::SaliencyMapMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::SaliencyMapMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::SaliencyMapBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::SaliencyMapBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::VisualTrackerMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::VisualTrackerMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::VisualTrackerBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::VisualTrackerBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::CameraCtrlBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::CameraCtrlBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::CameraCtrlMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::CameraCtrlMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::SegmenterMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::SegmenterMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::SegmenterBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::SegmenterBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::InfrotemporalCortexBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::InfrotemporalCortexBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::InfrotemporalCortexMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::InfrotemporalCortexMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::HippocampusBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::HippocampusBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::HippocampusMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::HippocampusMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::PrimaryMotorCortexBiasMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::PrimaryMotorCortexBiasMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::PrimaryMotorCortexRelativeServoMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::PrimaryMotorCortexResetEncodersMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::PrimaryMotorCortexMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::PrimaryMotorCortexMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::GUIInputMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::GUIInputMessage* p) { return p; }

::Ice::Object* IceInternal::upCast(::SimEvents::GUIOutputMessage* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::SimEvents::GUIOutputMessage* p) { return p; }

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::EventMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::EventMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::EventsPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::Events;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::RetinaMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::RetinaMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::VisualCortexMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::VisualCortexMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::SaliencyMapMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::SaliencyMapMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::SaliencyMapBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::SaliencyMapBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::VisualTrackerMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::VisualTrackerMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::VisualTrackerBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::VisualTrackerBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::CameraCtrlBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::CameraCtrlBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::CameraCtrlMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::CameraCtrlMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::SegmenterMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::SegmenterMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::SegmenterBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::SegmenterBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::InfrotemporalCortexBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::InfrotemporalCortexBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::InfrotemporalCortexMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::InfrotemporalCortexMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::HippocampusBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::HippocampusBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::HippocampusMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::HippocampusMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::PrimaryMotorCortexBiasMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::PrimaryMotorCortexBiasMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::PrimaryMotorCortexRelativeServoMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::PrimaryMotorCortexResetEncodersMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::PrimaryMotorCortexMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::PrimaryMotorCortexMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::GUIInputMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::GUIInputMessage;
        v->__copyFrom(proxy);
    }
}

void
SimEvents::__read(::IceInternal::BasicStream* __is, ::SimEvents::GUIOutputMessagePrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::SimEvents::GUIOutputMessage;
        v->__copyFrom(proxy);
    }
}

bool
SimEvents::LocInfo::operator==(const LocInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(lowresMaxpos != __rhs.lowresMaxpos)
    {
        return false;
    }
    if(fullresMaxpos != __rhs.fullresMaxpos)
    {
        return false;
    }
    if(maxval != __rhs.maxval)
    {
        return false;
    }
    return true;
}

bool
SimEvents::LocInfo::operator<(const LocInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(lowresMaxpos < __rhs.lowresMaxpos)
    {
        return true;
    }
    else if(__rhs.lowresMaxpos < lowresMaxpos)
    {
        return false;
    }
    if(fullresMaxpos < __rhs.fullresMaxpos)
    {
        return true;
    }
    else if(__rhs.fullresMaxpos < fullresMaxpos)
    {
        return false;
    }
    if(maxval < __rhs.maxval)
    {
        return true;
    }
    else if(__rhs.maxval < maxval)
    {
        return false;
    }
    return false;
}

void
SimEvents::LocInfo::__write(::IceInternal::BasicStream* __os) const
{
    lowresMaxpos.__write(__os);
    fullresMaxpos.__write(__os);
    __os->write(maxval);
}

void
SimEvents::LocInfo::__read(::IceInternal::BasicStream* __is)
{
    lowresMaxpos.__read(__is);
    fullresMaxpos.__read(__is);
    __is->read(maxval);
}

void
SimEvents::__writeLocInfoSeq(::IceInternal::BasicStream* __os, const ::SimEvents::LocInfo* begin, const ::SimEvents::LocInfo* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
SimEvents::__readLocInfoSeq(::IceInternal::BasicStream* __is, ::SimEvents::LocInfoSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 17);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

bool
SimEvents::TrackInfo::operator==(const TrackInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(pos != __rhs.pos)
    {
        return false;
    }
    if(err != __rhs.err)
    {
        return false;
    }
    return true;
}

bool
SimEvents::TrackInfo::operator<(const TrackInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(pos < __rhs.pos)
    {
        return true;
    }
    else if(__rhs.pos < pos)
    {
        return false;
    }
    if(err < __rhs.err)
    {
        return true;
    }
    else if(__rhs.err < err)
    {
        return false;
    }
    return false;
}

void
SimEvents::TrackInfo::__write(::IceInternal::BasicStream* __os) const
{
    pos.__write(__os);
    __os->write(err);
}

void
SimEvents::TrackInfo::__read(::IceInternal::BasicStream* __is)
{
    pos.__read(__is);
    __is->read(err);
}

void
SimEvents::__writeTrackInfoSeq(::IceInternal::BasicStream* __os, const ::SimEvents::TrackInfo* begin, const ::SimEvents::TrackInfo* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
SimEvents::__readTrackInfoSeq(::IceInternal::BasicStream* __is, ::SimEvents::TrackInfoSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->checkFixedSeq(sz, 12);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
    }
}

bool
SimEvents::SegInfo::operator==(const SegInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(loc != __rhs.loc)
    {
        return false;
    }
    if(rect != __rhs.rect)
    {
        return false;
    }
    if(img != __rhs.img)
    {
        return false;
    }
    return true;
}

bool
SimEvents::SegInfo::operator<(const SegInfo& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(loc < __rhs.loc)
    {
        return true;
    }
    else if(__rhs.loc < loc)
    {
        return false;
    }
    if(rect < __rhs.rect)
    {
        return true;
    }
    else if(__rhs.rect < rect)
    {
        return false;
    }
    if(img < __rhs.img)
    {
        return true;
    }
    else if(__rhs.img < img)
    {
        return false;
    }
    return false;
}

void
SimEvents::SegInfo::__write(::IceInternal::BasicStream* __os) const
{
    loc.__write(__os);
    rect.__write(__os);
    img.__write(__os);
}

void
SimEvents::SegInfo::__read(::IceInternal::BasicStream* __is)
{
    loc.__read(__is);
    rect.__read(__is);
    img.__read(__is);
}

void
SimEvents::__writeSegInfoSeq(::IceInternal::BasicStream* __os, const ::SimEvents::SegInfo* begin, const ::SimEvents::SegInfo* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
SimEvents::__readSegInfoSeq(::IceInternal::BasicStream* __is, ::SimEvents::SegInfoSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 37);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
SimEvents::ObjectState::operator==(const ObjectState& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(objectName != __rhs.objectName)
    {
        return false;
    }
    if(objectMsg != __rhs.objectMsg)
    {
        return false;
    }
    if(inDanger != __rhs.inDanger)
    {
        return false;
    }
    if(loc != __rhs.loc)
    {
        return false;
    }
    if(pos != __rhs.pos)
    {
        return false;
    }
    if(rotation != __rhs.rotation)
    {
        return false;
    }
    if(size != __rhs.size)
    {
        return false;
    }
    return true;
}

bool
SimEvents::ObjectState::operator<(const ObjectState& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(objectName < __rhs.objectName)
    {
        return true;
    }
    else if(__rhs.objectName < objectName)
    {
        return false;
    }
    if(objectMsg < __rhs.objectMsg)
    {
        return true;
    }
    else if(__rhs.objectMsg < objectMsg)
    {
        return false;
    }
    if(inDanger < __rhs.inDanger)
    {
        return true;
    }
    else if(__rhs.inDanger < inDanger)
    {
        return false;
    }
    if(loc < __rhs.loc)
    {
        return true;
    }
    else if(__rhs.loc < loc)
    {
        return false;
    }
    if(pos < __rhs.pos)
    {
        return true;
    }
    else if(__rhs.pos < pos)
    {
        return false;
    }
    if(rotation < __rhs.rotation)
    {
        return true;
    }
    else if(__rhs.rotation < rotation)
    {
        return false;
    }
    if(size < __rhs.size)
    {
        return true;
    }
    else if(__rhs.size < size)
    {
        return false;
    }
    return false;
}

void
SimEvents::ObjectState::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(objectName);
    __os->write(objectMsg);
    __os->write(inDanger);
    loc.__write(__os);
    pos.__write(__os);
    __os->write(rotation);
    __os->write(size);
}

void
SimEvents::ObjectState::__read(::IceInternal::BasicStream* __is)
{
    __is->read(objectName);
    __is->read(objectMsg);
    __is->read(inDanger);
    loc.__read(__is);
    pos.__read(__is);
    __is->read(rotation);
    __is->read(size);
}

void
SimEvents::__writeObjectsStateSeq(::IceInternal::BasicStream* __os, const ::SimEvents::ObjectState* begin, const ::SimEvents::ObjectState* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
SimEvents::__readObjectsStateSeq(::IceInternal::BasicStream* __is, ::SimEvents::ObjectsStateSeq& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 31);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

bool
SimEvents::ArmPosition::operator==(const ArmPosition& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(x != __rhs.x)
    {
        return false;
    }
    if(y != __rhs.y)
    {
        return false;
    }
    if(z != __rhs.z)
    {
        return false;
    }
    if(rot != __rhs.rot)
    {
        return false;
    }
    if(roll != __rhs.roll)
    {
        return false;
    }
    if(gripper != __rhs.gripper)
    {
        return false;
    }
    return true;
}

bool
SimEvents::ArmPosition::operator<(const ArmPosition& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(x < __rhs.x)
    {
        return true;
    }
    else if(__rhs.x < x)
    {
        return false;
    }
    if(y < __rhs.y)
    {
        return true;
    }
    else if(__rhs.y < y)
    {
        return false;
    }
    if(z < __rhs.z)
    {
        return true;
    }
    else if(__rhs.z < z)
    {
        return false;
    }
    if(rot < __rhs.rot)
    {
        return true;
    }
    else if(__rhs.rot < rot)
    {
        return false;
    }
    if(roll < __rhs.roll)
    {
        return true;
    }
    else if(__rhs.roll < roll)
    {
        return false;
    }
    if(gripper < __rhs.gripper)
    {
        return true;
    }
    else if(__rhs.gripper < gripper)
    {
        return false;
    }
    return false;
}

void
SimEvents::ArmPosition::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(x);
    __os->write(y);
    __os->write(z);
    __os->write(rot);
    __os->write(roll);
    __os->write(gripper);
}

void
SimEvents::ArmPosition::__read(::IceInternal::BasicStream* __is)
{
    __is->read(x);
    __is->read(y);
    __is->read(z);
    __is->read(rot);
    __is->read(roll);
    __is->read(gripper);
}

const ::std::string&
IceProxy::SimEvents::EventMessage::ice_staticId()
{
    return ::SimEvents::EventMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::EventMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::EventMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::EventMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::EventMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::EventMessage::__newInstance() const
{
    return new EventMessage;
}

void
IceProxy::SimEvents::Events::evolve(const ::SimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __delBase = __getDelegate(false);
            ::IceDelegate::SimEvents::Events* __del = dynamic_cast< ::IceDelegate::SimEvents::Events*>(__delBase.get());
            __del->evolve(eMsg, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::SimEvents::Events::ice_staticId()
{
    return ::SimEvents::Events::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::Events::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::Events);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::Events::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::Events);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::Events::__newInstance() const
{
    return new Events;
}

const ::std::string&
IceProxy::SimEvents::RetinaMessage::ice_staticId()
{
    return ::SimEvents::RetinaMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::RetinaMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::RetinaMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::RetinaMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::RetinaMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::RetinaMessage::__newInstance() const
{
    return new RetinaMessage;
}

const ::std::string&
IceProxy::SimEvents::VisualCortexMessage::ice_staticId()
{
    return ::SimEvents::VisualCortexMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::VisualCortexMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::VisualCortexMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::VisualCortexMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::VisualCortexMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::VisualCortexMessage::__newInstance() const
{
    return new VisualCortexMessage;
}

const ::std::string&
IceProxy::SimEvents::SaliencyMapMessage::ice_staticId()
{
    return ::SimEvents::SaliencyMapMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::SaliencyMapMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::SaliencyMapMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::SaliencyMapMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::SaliencyMapMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::SaliencyMapMessage::__newInstance() const
{
    return new SaliencyMapMessage;
}

const ::std::string&
IceProxy::SimEvents::SaliencyMapBiasMessage::ice_staticId()
{
    return ::SimEvents::SaliencyMapBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::SaliencyMapBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::SaliencyMapBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::SaliencyMapBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::SaliencyMapBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::SaliencyMapBiasMessage::__newInstance() const
{
    return new SaliencyMapBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::VisualTrackerMessage::ice_staticId()
{
    return ::SimEvents::VisualTrackerMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::VisualTrackerMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::VisualTrackerMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::VisualTrackerMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::VisualTrackerMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::VisualTrackerMessage::__newInstance() const
{
    return new VisualTrackerMessage;
}

const ::std::string&
IceProxy::SimEvents::VisualTrackerBiasMessage::ice_staticId()
{
    return ::SimEvents::VisualTrackerBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::VisualTrackerBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::VisualTrackerBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::VisualTrackerBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::VisualTrackerBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::VisualTrackerBiasMessage::__newInstance() const
{
    return new VisualTrackerBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::CameraCtrlBiasMessage::ice_staticId()
{
    return ::SimEvents::CameraCtrlBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::CameraCtrlBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::CameraCtrlBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::CameraCtrlBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::CameraCtrlBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::CameraCtrlBiasMessage::__newInstance() const
{
    return new CameraCtrlBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::CameraCtrlMessage::ice_staticId()
{
    return ::SimEvents::CameraCtrlMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::CameraCtrlMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::CameraCtrlMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::CameraCtrlMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::CameraCtrlMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::CameraCtrlMessage::__newInstance() const
{
    return new CameraCtrlMessage;
}

const ::std::string&
IceProxy::SimEvents::SegmenterMessage::ice_staticId()
{
    return ::SimEvents::SegmenterMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::SegmenterMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::SegmenterMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::SegmenterMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::SegmenterMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::SegmenterMessage::__newInstance() const
{
    return new SegmenterMessage;
}

const ::std::string&
IceProxy::SimEvents::SegmenterBiasMessage::ice_staticId()
{
    return ::SimEvents::SegmenterBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::SegmenterBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::SegmenterBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::SegmenterBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::SegmenterBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::SegmenterBiasMessage::__newInstance() const
{
    return new SegmenterBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId()
{
    return ::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::InfrotemporalCortexBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::InfrotemporalCortexBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::InfrotemporalCortexBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::InfrotemporalCortexBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::InfrotemporalCortexBiasMessage::__newInstance() const
{
    return new InfrotemporalCortexBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::InfrotemporalCortexMessage::ice_staticId()
{
    return ::SimEvents::InfrotemporalCortexMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::InfrotemporalCortexMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::InfrotemporalCortexMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::InfrotemporalCortexMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::InfrotemporalCortexMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::InfrotemporalCortexMessage::__newInstance() const
{
    return new InfrotemporalCortexMessage;
}

const ::std::string&
IceProxy::SimEvents::HippocampusBiasMessage::ice_staticId()
{
    return ::SimEvents::HippocampusBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::HippocampusBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::HippocampusBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::HippocampusBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::HippocampusBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::HippocampusBiasMessage::__newInstance() const
{
    return new HippocampusBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::HippocampusMessage::ice_staticId()
{
    return ::SimEvents::HippocampusMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::HippocampusMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::HippocampusMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::HippocampusMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::HippocampusMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::HippocampusMessage::__newInstance() const
{
    return new HippocampusMessage;
}

const ::std::string&
IceProxy::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId()
{
    return ::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexBiasMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::PrimaryMotorCortexBiasMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexBiasMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::PrimaryMotorCortexBiasMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::PrimaryMotorCortexBiasMessage::__newInstance() const
{
    return new PrimaryMotorCortexBiasMessage;
}

const ::std::string&
IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId()
{
    return ::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::PrimaryMotorCortexRelativeServoMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::PrimaryMotorCortexRelativeServoMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage::__newInstance() const
{
    return new PrimaryMotorCortexRelativeServoMessage;
}

const ::std::string&
IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId()
{
    return ::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::PrimaryMotorCortexResetEncodersMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::PrimaryMotorCortexResetEncodersMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage::__newInstance() const
{
    return new PrimaryMotorCortexResetEncodersMessage;
}

const ::std::string&
IceProxy::SimEvents::PrimaryMotorCortexMessage::ice_staticId()
{
    return ::SimEvents::PrimaryMotorCortexMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::PrimaryMotorCortexMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::PrimaryMotorCortexMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::PrimaryMotorCortexMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::PrimaryMotorCortexMessage::__newInstance() const
{
    return new PrimaryMotorCortexMessage;
}

const ::std::string&
IceProxy::SimEvents::GUIInputMessage::ice_staticId()
{
    return ::SimEvents::GUIInputMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::GUIInputMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::GUIInputMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::GUIInputMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::GUIInputMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::GUIInputMessage::__newInstance() const
{
    return new GUIInputMessage;
}

const ::std::string&
IceProxy::SimEvents::GUIOutputMessage::ice_staticId()
{
    return ::SimEvents::GUIOutputMessage::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::SimEvents::GUIOutputMessage::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::SimEvents::GUIOutputMessage);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::SimEvents::GUIOutputMessage::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::SimEvents::GUIOutputMessage);
}

::IceProxy::Ice::Object*
IceProxy::SimEvents::GUIOutputMessage::__newInstance() const
{
    return new GUIOutputMessage;
}

void
IceDelegateM::SimEvents::Events::evolve(const ::SimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __SimEvents__Events__evolve_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(eMsg.get())));
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    if(!__og.is()->b.empty())
    {
        try
        {
            if(!__ok)
            {
                try
                {
                    __og.throwUserException();
                }
                catch(const ::Ice::UserException& __ex)
                {
                    ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                    throw __uue;
                }
            }
            __og.is()->skipEmptyEncaps();
        }
        catch(const ::Ice::LocalException& __ex)
        {
            throw ::IceInternal::LocalExceptionWrapper(__ex, false);
        }
    }
}

void
IceDelegateD::SimEvents::Events::evolve(const ::SimEvents::EventMessagePtr& eMsg, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::SimEvents::EventMessagePtr& eMsg, const ::Ice::Current& __current) :
            ::IceInternal::Direct(__current),
            _m_eMsg(eMsg)
        {
        }

        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::SimEvents::Events* servant = dynamic_cast< ::SimEvents::Events*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            servant->evolve(_m_eMsg, _current);
            return ::Ice::DispatchOK;
        }

    private:

        const ::SimEvents::EventMessagePtr& _m_eMsg;
    };

    ::Ice::Current __current;
    __initCurrent(__current, __SimEvents__Events__evolve_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(eMsg, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ice::ObjectPtr
SimEvents::EventMessage::ice_clone() const
{
    ::SimEvents::EventMessagePtr __p = new ::SimEvents::EventMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__EventMessage_ids[2] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage"
};

bool
SimEvents::EventMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__EventMessage_ids, __SimEvents__EventMessage_ids + 2, _s);
}

::std::vector< ::std::string>
SimEvents::EventMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__EventMessage_ids[0], &__SimEvents__EventMessage_ids[2]);
}

const ::std::string&
SimEvents::EventMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__EventMessage_ids[1];
}

const ::std::string&
SimEvents::EventMessage::ice_staticId()
{
    return __SimEvents__EventMessage_ids[1];
}

void
SimEvents::EventMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
SimEvents::EventMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
SimEvents::EventMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::EventMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::EventMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::EventMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__EventMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::EventMessage::ice_staticId());
        return new ::SimEvents::EventMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__EventMessage_Ptr = new __F__SimEvents__EventMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::EventMessage::ice_factory()
{
    return __F__SimEvents__EventMessage_Ptr;
}

class __F__SimEvents__EventMessage__Init
{
public:

    __F__SimEvents__EventMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::EventMessage::ice_staticId(), ::SimEvents::EventMessage::ice_factory());
    }

    ~__F__SimEvents__EventMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::EventMessage::ice_staticId());
    }
};

static __F__SimEvents__EventMessage__Init __F__SimEvents__EventMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__EventMessage__initializer() {} }
#endif

void
SimEvents::__patch__EventMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::EventMessagePtr* p = static_cast< ::SimEvents::EventMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::EventMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::EventMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::EventMessage& l, const ::SimEvents::EventMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::EventMessage& l, const ::SimEvents::EventMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
SimEvents::Events::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __SimEvents__Events_ids[2] =
{
    "::Ice::Object",
    "::SimEvents::Events"
};

bool
SimEvents::Events::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__Events_ids, __SimEvents__Events_ids + 2, _s);
}

::std::vector< ::std::string>
SimEvents::Events::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__Events_ids[0], &__SimEvents__Events_ids[2]);
}

const ::std::string&
SimEvents::Events::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__Events_ids[1];
}

const ::std::string&
SimEvents::Events::ice_staticId()
{
    return __SimEvents__Events_ids[1];
}

::Ice::DispatchStatus
SimEvents::Events::___evolve(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::SimEvents::EventMessagePtr eMsg;
    __is->read(::SimEvents::__patch__EventMessagePtr, &eMsg);
    __is->readPendingObjects();
    __is->endReadEncaps();
    evolve(eMsg, __current);
    return ::Ice::DispatchOK;
}

static ::std::string __SimEvents__Events_all[] =
{
    "evolve",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

::Ice::DispatchStatus
SimEvents::Events::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__SimEvents__Events_all, __SimEvents__Events_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __SimEvents__Events_all)
    {
        case 0:
        {
            return ___evolve(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
SimEvents::Events::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
SimEvents::Events::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
SimEvents::Events::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::Events was not generated with stream support";
    throw ex;
}

void
SimEvents::Events::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::Events was not generated with stream support";
    throw ex;
}

void
SimEvents::__patch__EventsPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::EventsPtr* p = static_cast< ::SimEvents::EventsPtr*>(__addr);
    assert(p);
    *p = ::SimEvents::EventsPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::Events::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::Events& l, const ::SimEvents::Events& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::Events& l, const ::SimEvents::Events& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::RetinaMessage::RetinaMessage(const ::ImageIceMod::ImageIce& __ice_img) :
    img(__ice_img)
{
}

::Ice::ObjectPtr
SimEvents::RetinaMessage::ice_clone() const
{
    ::SimEvents::RetinaMessagePtr __p = new ::SimEvents::RetinaMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__RetinaMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::RetinaMessage"
};

bool
SimEvents::RetinaMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__RetinaMessage_ids, __SimEvents__RetinaMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::RetinaMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__RetinaMessage_ids[0], &__SimEvents__RetinaMessage_ids[3]);
}

const ::std::string&
SimEvents::RetinaMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__RetinaMessage_ids[2];
}

const ::std::string&
SimEvents::RetinaMessage::ice_staticId()
{
    return __SimEvents__RetinaMessage_ids[2];
}

void
SimEvents::RetinaMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    img.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::RetinaMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    img.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::RetinaMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::RetinaMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::RetinaMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::RetinaMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__RetinaMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::RetinaMessage::ice_staticId());
        return new ::SimEvents::RetinaMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__RetinaMessage_Ptr = new __F__SimEvents__RetinaMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::RetinaMessage::ice_factory()
{
    return __F__SimEvents__RetinaMessage_Ptr;
}

class __F__SimEvents__RetinaMessage__Init
{
public:

    __F__SimEvents__RetinaMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::RetinaMessage::ice_staticId(), ::SimEvents::RetinaMessage::ice_factory());
    }

    ~__F__SimEvents__RetinaMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::RetinaMessage::ice_staticId());
    }
};

static __F__SimEvents__RetinaMessage__Init __F__SimEvents__RetinaMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__RetinaMessage__initializer() {} }
#endif

void
SimEvents::__patch__RetinaMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::RetinaMessagePtr* p = static_cast< ::SimEvents::RetinaMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::RetinaMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::RetinaMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::RetinaMessage& l, const ::SimEvents::RetinaMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::RetinaMessage& l, const ::SimEvents::RetinaMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::VisualCortexMessage::VisualCortexMessage(const ::ImageIceMod::ImageIce& __ice_vco) :
    vco(__ice_vco)
{
}

::Ice::ObjectPtr
SimEvents::VisualCortexMessage::ice_clone() const
{
    ::SimEvents::VisualCortexMessagePtr __p = new ::SimEvents::VisualCortexMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__VisualCortexMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::VisualCortexMessage"
};

bool
SimEvents::VisualCortexMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__VisualCortexMessage_ids, __SimEvents__VisualCortexMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::VisualCortexMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__VisualCortexMessage_ids[0], &__SimEvents__VisualCortexMessage_ids[3]);
}

const ::std::string&
SimEvents::VisualCortexMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__VisualCortexMessage_ids[2];
}

const ::std::string&
SimEvents::VisualCortexMessage::ice_staticId()
{
    return __SimEvents__VisualCortexMessage_ids[2];
}

void
SimEvents::VisualCortexMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    vco.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::VisualCortexMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    vco.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::VisualCortexMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualCortexMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::VisualCortexMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualCortexMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__VisualCortexMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::VisualCortexMessage::ice_staticId());
        return new ::SimEvents::VisualCortexMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__VisualCortexMessage_Ptr = new __F__SimEvents__VisualCortexMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::VisualCortexMessage::ice_factory()
{
    return __F__SimEvents__VisualCortexMessage_Ptr;
}

class __F__SimEvents__VisualCortexMessage__Init
{
public:

    __F__SimEvents__VisualCortexMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::VisualCortexMessage::ice_staticId(), ::SimEvents::VisualCortexMessage::ice_factory());
    }

    ~__F__SimEvents__VisualCortexMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::VisualCortexMessage::ice_staticId());
    }
};

static __F__SimEvents__VisualCortexMessage__Init __F__SimEvents__VisualCortexMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__VisualCortexMessage__initializer() {} }
#endif

void
SimEvents::__patch__VisualCortexMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::VisualCortexMessagePtr* p = static_cast< ::SimEvents::VisualCortexMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::VisualCortexMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::VisualCortexMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::VisualCortexMessage& l, const ::SimEvents::VisualCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::VisualCortexMessage& l, const ::SimEvents::VisualCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::SaliencyMapMessage::SaliencyMapMessage(const ::ImageIceMod::ImageIce& __ice_smap, const ::SimEvents::LocInfoSeq& __ice_nMostSalientLoc) :
    smap(__ice_smap),
    nMostSalientLoc(__ice_nMostSalientLoc)
{
}

::Ice::ObjectPtr
SimEvents::SaliencyMapMessage::ice_clone() const
{
    ::SimEvents::SaliencyMapMessagePtr __p = new ::SimEvents::SaliencyMapMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__SaliencyMapMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::SaliencyMapMessage"
};

bool
SimEvents::SaliencyMapMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__SaliencyMapMessage_ids, __SimEvents__SaliencyMapMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::SaliencyMapMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__SaliencyMapMessage_ids[0], &__SimEvents__SaliencyMapMessage_ids[3]);
}

const ::std::string&
SimEvents::SaliencyMapMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__SaliencyMapMessage_ids[2];
}

const ::std::string&
SimEvents::SaliencyMapMessage::ice_staticId()
{
    return __SimEvents__SaliencyMapMessage_ids[2];
}

void
SimEvents::SaliencyMapMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    smap.__write(__os);
    if(nMostSalientLoc.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeLocInfoSeq(__os, &nMostSalientLoc[0], &nMostSalientLoc[0] + nMostSalientLoc.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::SaliencyMapMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    smap.__read(__is);
    ::SimEvents::__readLocInfoSeq(__is, nMostSalientLoc);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::SaliencyMapMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SaliencyMapMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::SaliencyMapMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SaliencyMapMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__SaliencyMapMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::SaliencyMapMessage::ice_staticId());
        return new ::SimEvents::SaliencyMapMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__SaliencyMapMessage_Ptr = new __F__SimEvents__SaliencyMapMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::SaliencyMapMessage::ice_factory()
{
    return __F__SimEvents__SaliencyMapMessage_Ptr;
}

class __F__SimEvents__SaliencyMapMessage__Init
{
public:

    __F__SimEvents__SaliencyMapMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::SaliencyMapMessage::ice_staticId(), ::SimEvents::SaliencyMapMessage::ice_factory());
    }

    ~__F__SimEvents__SaliencyMapMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::SaliencyMapMessage::ice_staticId());
    }
};

static __F__SimEvents__SaliencyMapMessage__Init __F__SimEvents__SaliencyMapMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__SaliencyMapMessage__initializer() {} }
#endif

void
SimEvents::__patch__SaliencyMapMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::SaliencyMapMessagePtr* p = static_cast< ::SimEvents::SaliencyMapMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::SaliencyMapMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::SaliencyMapMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::SaliencyMapMessage& l, const ::SimEvents::SaliencyMapMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::SaliencyMapMessage& l, const ::SimEvents::SaliencyMapMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::SaliencyMapBiasMessage::SaliencyMapBiasMessage(const ::ImageIceMod::ImageIce& __ice_biasImg) :
    biasImg(__ice_biasImg)
{
}

::Ice::ObjectPtr
SimEvents::SaliencyMapBiasMessage::ice_clone() const
{
    ::SimEvents::SaliencyMapBiasMessagePtr __p = new ::SimEvents::SaliencyMapBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__SaliencyMapBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::SaliencyMapBiasMessage"
};

bool
SimEvents::SaliencyMapBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__SaliencyMapBiasMessage_ids, __SimEvents__SaliencyMapBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::SaliencyMapBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__SaliencyMapBiasMessage_ids[0], &__SimEvents__SaliencyMapBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::SaliencyMapBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__SaliencyMapBiasMessage_ids[2];
}

const ::std::string&
SimEvents::SaliencyMapBiasMessage::ice_staticId()
{
    return __SimEvents__SaliencyMapBiasMessage_ids[2];
}

void
SimEvents::SaliencyMapBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    biasImg.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::SaliencyMapBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    biasImg.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::SaliencyMapBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SaliencyMapBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::SaliencyMapBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SaliencyMapBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__SaliencyMapBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::SaliencyMapBiasMessage::ice_staticId());
        return new ::SimEvents::SaliencyMapBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__SaliencyMapBiasMessage_Ptr = new __F__SimEvents__SaliencyMapBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::SaliencyMapBiasMessage::ice_factory()
{
    return __F__SimEvents__SaliencyMapBiasMessage_Ptr;
}

class __F__SimEvents__SaliencyMapBiasMessage__Init
{
public:

    __F__SimEvents__SaliencyMapBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::SaliencyMapBiasMessage::ice_staticId(), ::SimEvents::SaliencyMapBiasMessage::ice_factory());
    }

    ~__F__SimEvents__SaliencyMapBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::SaliencyMapBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__SaliencyMapBiasMessage__Init __F__SimEvents__SaliencyMapBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__SaliencyMapBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__SaliencyMapBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::SaliencyMapBiasMessagePtr* p = static_cast< ::SimEvents::SaliencyMapBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::SaliencyMapBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::SaliencyMapBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::SaliencyMapBiasMessage& l, const ::SimEvents::SaliencyMapBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::SaliencyMapBiasMessage& l, const ::SimEvents::SaliencyMapBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::VisualTrackerMessage::VisualTrackerMessage(const ::SimEvents::TrackInfoSeq& __ice_trackLocs) :
    trackLocs(__ice_trackLocs)
{
}

::Ice::ObjectPtr
SimEvents::VisualTrackerMessage::ice_clone() const
{
    ::SimEvents::VisualTrackerMessagePtr __p = new ::SimEvents::VisualTrackerMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__VisualTrackerMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::VisualTrackerMessage"
};

bool
SimEvents::VisualTrackerMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__VisualTrackerMessage_ids, __SimEvents__VisualTrackerMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::VisualTrackerMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__VisualTrackerMessage_ids[0], &__SimEvents__VisualTrackerMessage_ids[3]);
}

const ::std::string&
SimEvents::VisualTrackerMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__VisualTrackerMessage_ids[2];
}

const ::std::string&
SimEvents::VisualTrackerMessage::ice_staticId()
{
    return __SimEvents__VisualTrackerMessage_ids[2];
}

void
SimEvents::VisualTrackerMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(trackLocs.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeTrackInfoSeq(__os, &trackLocs[0], &trackLocs[0] + trackLocs.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::VisualTrackerMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::SimEvents::__readTrackInfoSeq(__is, trackLocs);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::VisualTrackerMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualTrackerMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::VisualTrackerMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualTrackerMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__VisualTrackerMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::VisualTrackerMessage::ice_staticId());
        return new ::SimEvents::VisualTrackerMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__VisualTrackerMessage_Ptr = new __F__SimEvents__VisualTrackerMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::VisualTrackerMessage::ice_factory()
{
    return __F__SimEvents__VisualTrackerMessage_Ptr;
}

class __F__SimEvents__VisualTrackerMessage__Init
{
public:

    __F__SimEvents__VisualTrackerMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::VisualTrackerMessage::ice_staticId(), ::SimEvents::VisualTrackerMessage::ice_factory());
    }

    ~__F__SimEvents__VisualTrackerMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::VisualTrackerMessage::ice_staticId());
    }
};

static __F__SimEvents__VisualTrackerMessage__Init __F__SimEvents__VisualTrackerMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__VisualTrackerMessage__initializer() {} }
#endif

void
SimEvents::__patch__VisualTrackerMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::VisualTrackerMessagePtr* p = static_cast< ::SimEvents::VisualTrackerMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::VisualTrackerMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::VisualTrackerMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::VisualTrackerMessage& l, const ::SimEvents::VisualTrackerMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::VisualTrackerMessage& l, const ::SimEvents::VisualTrackerMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::VisualTrackerBiasMessage::VisualTrackerBiasMessage(const ::SimEvents::TrackInfoSeq& __ice_locToTrack) :
    locToTrack(__ice_locToTrack)
{
}

::Ice::ObjectPtr
SimEvents::VisualTrackerBiasMessage::ice_clone() const
{
    ::SimEvents::VisualTrackerBiasMessagePtr __p = new ::SimEvents::VisualTrackerBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__VisualTrackerBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::VisualTrackerBiasMessage"
};

bool
SimEvents::VisualTrackerBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__VisualTrackerBiasMessage_ids, __SimEvents__VisualTrackerBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::VisualTrackerBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__VisualTrackerBiasMessage_ids[0], &__SimEvents__VisualTrackerBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::VisualTrackerBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__VisualTrackerBiasMessage_ids[2];
}

const ::std::string&
SimEvents::VisualTrackerBiasMessage::ice_staticId()
{
    return __SimEvents__VisualTrackerBiasMessage_ids[2];
}

void
SimEvents::VisualTrackerBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(locToTrack.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeTrackInfoSeq(__os, &locToTrack[0], &locToTrack[0] + locToTrack.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::VisualTrackerBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::SimEvents::__readTrackInfoSeq(__is, locToTrack);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::VisualTrackerBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualTrackerBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::VisualTrackerBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::VisualTrackerBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__VisualTrackerBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::VisualTrackerBiasMessage::ice_staticId());
        return new ::SimEvents::VisualTrackerBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__VisualTrackerBiasMessage_Ptr = new __F__SimEvents__VisualTrackerBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::VisualTrackerBiasMessage::ice_factory()
{
    return __F__SimEvents__VisualTrackerBiasMessage_Ptr;
}

class __F__SimEvents__VisualTrackerBiasMessage__Init
{
public:

    __F__SimEvents__VisualTrackerBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::VisualTrackerBiasMessage::ice_staticId(), ::SimEvents::VisualTrackerBiasMessage::ice_factory());
    }

    ~__F__SimEvents__VisualTrackerBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::VisualTrackerBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__VisualTrackerBiasMessage__Init __F__SimEvents__VisualTrackerBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__VisualTrackerBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__VisualTrackerBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::VisualTrackerBiasMessagePtr* p = static_cast< ::SimEvents::VisualTrackerBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::VisualTrackerBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::VisualTrackerBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::VisualTrackerBiasMessage& l, const ::SimEvents::VisualTrackerBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::VisualTrackerBiasMessage& l, const ::SimEvents::VisualTrackerBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::CameraCtrlBiasMessage::CameraCtrlBiasMessage(bool __ice_zoomIn, bool __ice_zoomOut, bool __ice_initPtz) :
    zoomIn(__ice_zoomIn),
    zoomOut(__ice_zoomOut),
    initPtz(__ice_initPtz)
{
}

::Ice::ObjectPtr
SimEvents::CameraCtrlBiasMessage::ice_clone() const
{
    ::SimEvents::CameraCtrlBiasMessagePtr __p = new ::SimEvents::CameraCtrlBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__CameraCtrlBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::CameraCtrlBiasMessage",
    "::SimEvents::EventMessage"
};

bool
SimEvents::CameraCtrlBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__CameraCtrlBiasMessage_ids, __SimEvents__CameraCtrlBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::CameraCtrlBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__CameraCtrlBiasMessage_ids[0], &__SimEvents__CameraCtrlBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::CameraCtrlBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__CameraCtrlBiasMessage_ids[1];
}

const ::std::string&
SimEvents::CameraCtrlBiasMessage::ice_staticId()
{
    return __SimEvents__CameraCtrlBiasMessage_ids[1];
}

void
SimEvents::CameraCtrlBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(zoomIn);
    __os->write(zoomOut);
    __os->write(initPtz);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::CameraCtrlBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(zoomIn);
    __is->read(zoomOut);
    __is->read(initPtz);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::CameraCtrlBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::CameraCtrlBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::CameraCtrlBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::CameraCtrlBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__CameraCtrlBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::CameraCtrlBiasMessage::ice_staticId());
        return new ::SimEvents::CameraCtrlBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__CameraCtrlBiasMessage_Ptr = new __F__SimEvents__CameraCtrlBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::CameraCtrlBiasMessage::ice_factory()
{
    return __F__SimEvents__CameraCtrlBiasMessage_Ptr;
}

class __F__SimEvents__CameraCtrlBiasMessage__Init
{
public:

    __F__SimEvents__CameraCtrlBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::CameraCtrlBiasMessage::ice_staticId(), ::SimEvents::CameraCtrlBiasMessage::ice_factory());
    }

    ~__F__SimEvents__CameraCtrlBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::CameraCtrlBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__CameraCtrlBiasMessage__Init __F__SimEvents__CameraCtrlBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__CameraCtrlBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__CameraCtrlBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::CameraCtrlBiasMessagePtr* p = static_cast< ::SimEvents::CameraCtrlBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::CameraCtrlBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::CameraCtrlBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::CameraCtrlBiasMessage& l, const ::SimEvents::CameraCtrlBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::CameraCtrlBiasMessage& l, const ::SimEvents::CameraCtrlBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::CameraCtrlMessage::CameraCtrlMessage(bool __ice_zoomDone, bool __ice_initPtzDone, ::Ice::Int __ice_pan, ::Ice::Int __ice_tilt) :
    zoomDone(__ice_zoomDone),
    initPtzDone(__ice_initPtzDone),
    pan(__ice_pan),
    tilt(__ice_tilt)
{
}

::Ice::ObjectPtr
SimEvents::CameraCtrlMessage::ice_clone() const
{
    ::SimEvents::CameraCtrlMessagePtr __p = new ::SimEvents::CameraCtrlMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__CameraCtrlMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::CameraCtrlMessage",
    "::SimEvents::EventMessage"
};

bool
SimEvents::CameraCtrlMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__CameraCtrlMessage_ids, __SimEvents__CameraCtrlMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::CameraCtrlMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__CameraCtrlMessage_ids[0], &__SimEvents__CameraCtrlMessage_ids[3]);
}

const ::std::string&
SimEvents::CameraCtrlMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__CameraCtrlMessage_ids[1];
}

const ::std::string&
SimEvents::CameraCtrlMessage::ice_staticId()
{
    return __SimEvents__CameraCtrlMessage_ids[1];
}

void
SimEvents::CameraCtrlMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(zoomDone);
    __os->write(initPtzDone);
    __os->write(pan);
    __os->write(tilt);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::CameraCtrlMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(zoomDone);
    __is->read(initPtzDone);
    __is->read(pan);
    __is->read(tilt);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::CameraCtrlMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::CameraCtrlMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::CameraCtrlMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::CameraCtrlMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__CameraCtrlMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::CameraCtrlMessage::ice_staticId());
        return new ::SimEvents::CameraCtrlMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__CameraCtrlMessage_Ptr = new __F__SimEvents__CameraCtrlMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::CameraCtrlMessage::ice_factory()
{
    return __F__SimEvents__CameraCtrlMessage_Ptr;
}

class __F__SimEvents__CameraCtrlMessage__Init
{
public:

    __F__SimEvents__CameraCtrlMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::CameraCtrlMessage::ice_staticId(), ::SimEvents::CameraCtrlMessage::ice_factory());
    }

    ~__F__SimEvents__CameraCtrlMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::CameraCtrlMessage::ice_staticId());
    }
};

static __F__SimEvents__CameraCtrlMessage__Init __F__SimEvents__CameraCtrlMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__CameraCtrlMessage__initializer() {} }
#endif

void
SimEvents::__patch__CameraCtrlMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::CameraCtrlMessagePtr* p = static_cast< ::SimEvents::CameraCtrlMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::CameraCtrlMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::CameraCtrlMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::CameraCtrlMessage& l, const ::SimEvents::CameraCtrlMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::CameraCtrlMessage& l, const ::SimEvents::CameraCtrlMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::SegmenterMessage::SegmenterMessage(const ::SimEvents::SegInfoSeq& __ice_segLocs) :
    segLocs(__ice_segLocs)
{
}

::Ice::ObjectPtr
SimEvents::SegmenterMessage::ice_clone() const
{
    ::SimEvents::SegmenterMessagePtr __p = new ::SimEvents::SegmenterMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__SegmenterMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::SegmenterMessage"
};

bool
SimEvents::SegmenterMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__SegmenterMessage_ids, __SimEvents__SegmenterMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::SegmenterMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__SegmenterMessage_ids[0], &__SimEvents__SegmenterMessage_ids[3]);
}

const ::std::string&
SimEvents::SegmenterMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__SegmenterMessage_ids[2];
}

const ::std::string&
SimEvents::SegmenterMessage::ice_staticId()
{
    return __SimEvents__SegmenterMessage_ids[2];
}

void
SimEvents::SegmenterMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(segLocs.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeSegInfoSeq(__os, &segLocs[0], &segLocs[0] + segLocs.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::SegmenterMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::SimEvents::__readSegInfoSeq(__is, segLocs);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::SegmenterMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SegmenterMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::SegmenterMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SegmenterMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__SegmenterMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::SegmenterMessage::ice_staticId());
        return new ::SimEvents::SegmenterMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__SegmenterMessage_Ptr = new __F__SimEvents__SegmenterMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::SegmenterMessage::ice_factory()
{
    return __F__SimEvents__SegmenterMessage_Ptr;
}

class __F__SimEvents__SegmenterMessage__Init
{
public:

    __F__SimEvents__SegmenterMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::SegmenterMessage::ice_staticId(), ::SimEvents::SegmenterMessage::ice_factory());
    }

    ~__F__SimEvents__SegmenterMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::SegmenterMessage::ice_staticId());
    }
};

static __F__SimEvents__SegmenterMessage__Init __F__SimEvents__SegmenterMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__SegmenterMessage__initializer() {} }
#endif

void
SimEvents::__patch__SegmenterMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::SegmenterMessagePtr* p = static_cast< ::SimEvents::SegmenterMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::SegmenterMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::SegmenterMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::SegmenterMessage& l, const ::SimEvents::SegmenterMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::SegmenterMessage& l, const ::SimEvents::SegmenterMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::SegmenterBiasMessage::SegmenterBiasMessage(const ::SimEvents::SegInfoSeq& __ice_regionsToSeg) :
    regionsToSeg(__ice_regionsToSeg)
{
}

::Ice::ObjectPtr
SimEvents::SegmenterBiasMessage::ice_clone() const
{
    ::SimEvents::SegmenterBiasMessagePtr __p = new ::SimEvents::SegmenterBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__SegmenterBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::SegmenterBiasMessage"
};

bool
SimEvents::SegmenterBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__SegmenterBiasMessage_ids, __SimEvents__SegmenterBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::SegmenterBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__SegmenterBiasMessage_ids[0], &__SimEvents__SegmenterBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::SegmenterBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__SegmenterBiasMessage_ids[2];
}

const ::std::string&
SimEvents::SegmenterBiasMessage::ice_staticId()
{
    return __SimEvents__SegmenterBiasMessage_ids[2];
}

void
SimEvents::SegmenterBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(regionsToSeg.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeSegInfoSeq(__os, &regionsToSeg[0], &regionsToSeg[0] + regionsToSeg.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::SegmenterBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::SimEvents::__readSegInfoSeq(__is, regionsToSeg);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::SegmenterBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SegmenterBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::SegmenterBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::SegmenterBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__SegmenterBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::SegmenterBiasMessage::ice_staticId());
        return new ::SimEvents::SegmenterBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__SegmenterBiasMessage_Ptr = new __F__SimEvents__SegmenterBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::SegmenterBiasMessage::ice_factory()
{
    return __F__SimEvents__SegmenterBiasMessage_Ptr;
}

class __F__SimEvents__SegmenterBiasMessage__Init
{
public:

    __F__SimEvents__SegmenterBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::SegmenterBiasMessage::ice_staticId(), ::SimEvents::SegmenterBiasMessage::ice_factory());
    }

    ~__F__SimEvents__SegmenterBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::SegmenterBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__SegmenterBiasMessage__Init __F__SimEvents__SegmenterBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__SegmenterBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__SegmenterBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::SegmenterBiasMessagePtr* p = static_cast< ::SimEvents::SegmenterBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::SegmenterBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::SegmenterBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::SegmenterBiasMessage& l, const ::SimEvents::SegmenterBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::SegmenterBiasMessage& l, const ::SimEvents::SegmenterBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::InfrotemporalCortexBiasMessage::InfrotemporalCortexBiasMessage(const ::ImageIceMod::ImageIce& __ice_img) :
    img(__ice_img)
{
}

::Ice::ObjectPtr
SimEvents::InfrotemporalCortexBiasMessage::ice_clone() const
{
    ::SimEvents::InfrotemporalCortexBiasMessagePtr __p = new ::SimEvents::InfrotemporalCortexBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__InfrotemporalCortexBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::InfrotemporalCortexBiasMessage"
};

bool
SimEvents::InfrotemporalCortexBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__InfrotemporalCortexBiasMessage_ids, __SimEvents__InfrotemporalCortexBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::InfrotemporalCortexBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__InfrotemporalCortexBiasMessage_ids[0], &__SimEvents__InfrotemporalCortexBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::InfrotemporalCortexBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__InfrotemporalCortexBiasMessage_ids[2];
}

const ::std::string&
SimEvents::InfrotemporalCortexBiasMessage::ice_staticId()
{
    return __SimEvents__InfrotemporalCortexBiasMessage_ids[2];
}

void
SimEvents::InfrotemporalCortexBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    img.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::InfrotemporalCortexBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    img.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::InfrotemporalCortexBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::InfrotemporalCortexBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::InfrotemporalCortexBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::InfrotemporalCortexBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__InfrotemporalCortexBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId());
        return new ::SimEvents::InfrotemporalCortexBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__InfrotemporalCortexBiasMessage_Ptr = new __F__SimEvents__InfrotemporalCortexBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::InfrotemporalCortexBiasMessage::ice_factory()
{
    return __F__SimEvents__InfrotemporalCortexBiasMessage_Ptr;
}

class __F__SimEvents__InfrotemporalCortexBiasMessage__Init
{
public:

    __F__SimEvents__InfrotemporalCortexBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId(), ::SimEvents::InfrotemporalCortexBiasMessage::ice_factory());
    }

    ~__F__SimEvents__InfrotemporalCortexBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__InfrotemporalCortexBiasMessage__Init __F__SimEvents__InfrotemporalCortexBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__InfrotemporalCortexBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__InfrotemporalCortexBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::InfrotemporalCortexBiasMessagePtr* p = static_cast< ::SimEvents::InfrotemporalCortexBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::InfrotemporalCortexBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::InfrotemporalCortexBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::InfrotemporalCortexBiasMessage& l, const ::SimEvents::InfrotemporalCortexBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::InfrotemporalCortexBiasMessage& l, const ::SimEvents::InfrotemporalCortexBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::InfrotemporalCortexMessage::InfrotemporalCortexMessage(const ::std::string& __ice_objectName, const ::ImageIceMod::Point2DIce& __ice_objLoc, ::Ice::Float __ice_rotation, ::Ice::Float __ice_confidence) :
    objectName(__ice_objectName),
    objLoc(__ice_objLoc),
    rotation(__ice_rotation),
    confidence(__ice_confidence)
{
}

::Ice::ObjectPtr
SimEvents::InfrotemporalCortexMessage::ice_clone() const
{
    ::SimEvents::InfrotemporalCortexMessagePtr __p = new ::SimEvents::InfrotemporalCortexMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__InfrotemporalCortexMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::InfrotemporalCortexMessage"
};

bool
SimEvents::InfrotemporalCortexMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__InfrotemporalCortexMessage_ids, __SimEvents__InfrotemporalCortexMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::InfrotemporalCortexMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__InfrotemporalCortexMessage_ids[0], &__SimEvents__InfrotemporalCortexMessage_ids[3]);
}

const ::std::string&
SimEvents::InfrotemporalCortexMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__InfrotemporalCortexMessage_ids[2];
}

const ::std::string&
SimEvents::InfrotemporalCortexMessage::ice_staticId()
{
    return __SimEvents__InfrotemporalCortexMessage_ids[2];
}

void
SimEvents::InfrotemporalCortexMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(objectName);
    objLoc.__write(__os);
    __os->write(rotation);
    __os->write(confidence);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::InfrotemporalCortexMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(objectName);
    objLoc.__read(__is);
    __is->read(rotation);
    __is->read(confidence);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::InfrotemporalCortexMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::InfrotemporalCortexMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::InfrotemporalCortexMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::InfrotemporalCortexMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__InfrotemporalCortexMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::InfrotemporalCortexMessage::ice_staticId());
        return new ::SimEvents::InfrotemporalCortexMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__InfrotemporalCortexMessage_Ptr = new __F__SimEvents__InfrotemporalCortexMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::InfrotemporalCortexMessage::ice_factory()
{
    return __F__SimEvents__InfrotemporalCortexMessage_Ptr;
}

class __F__SimEvents__InfrotemporalCortexMessage__Init
{
public:

    __F__SimEvents__InfrotemporalCortexMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::InfrotemporalCortexMessage::ice_staticId(), ::SimEvents::InfrotemporalCortexMessage::ice_factory());
    }

    ~__F__SimEvents__InfrotemporalCortexMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::InfrotemporalCortexMessage::ice_staticId());
    }
};

static __F__SimEvents__InfrotemporalCortexMessage__Init __F__SimEvents__InfrotemporalCortexMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__InfrotemporalCortexMessage__initializer() {} }
#endif

void
SimEvents::__patch__InfrotemporalCortexMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::InfrotemporalCortexMessagePtr* p = static_cast< ::SimEvents::InfrotemporalCortexMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::InfrotemporalCortexMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::InfrotemporalCortexMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::InfrotemporalCortexMessage& l, const ::SimEvents::InfrotemporalCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::InfrotemporalCortexMessage& l, const ::SimEvents::InfrotemporalCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::HippocampusBiasMessage::HippocampusBiasMessage(const ::ImageIceMod::Point2DIce& __ice_loc, ::Ice::Int __ice_pan, ::Ice::Int __ice_tilt, ::Ice::Float __ice_rotation, const ::std::string& __ice_objectName, const ::ImageIceMod::ImageIce& __ice_img) :
    loc(__ice_loc),
    pan(__ice_pan),
    tilt(__ice_tilt),
    rotation(__ice_rotation),
    objectName(__ice_objectName),
    img(__ice_img)
{
}

::Ice::ObjectPtr
SimEvents::HippocampusBiasMessage::ice_clone() const
{
    ::SimEvents::HippocampusBiasMessagePtr __p = new ::SimEvents::HippocampusBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__HippocampusBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::HippocampusBiasMessage"
};

bool
SimEvents::HippocampusBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__HippocampusBiasMessage_ids, __SimEvents__HippocampusBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::HippocampusBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__HippocampusBiasMessage_ids[0], &__SimEvents__HippocampusBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::HippocampusBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__HippocampusBiasMessage_ids[2];
}

const ::std::string&
SimEvents::HippocampusBiasMessage::ice_staticId()
{
    return __SimEvents__HippocampusBiasMessage_ids[2];
}

void
SimEvents::HippocampusBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    loc.__write(__os);
    __os->write(pan);
    __os->write(tilt);
    __os->write(rotation);
    __os->write(objectName);
    img.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::HippocampusBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    loc.__read(__is);
    __is->read(pan);
    __is->read(tilt);
    __is->read(rotation);
    __is->read(objectName);
    img.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::HippocampusBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::HippocampusBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::HippocampusBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::HippocampusBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__HippocampusBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::HippocampusBiasMessage::ice_staticId());
        return new ::SimEvents::HippocampusBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__HippocampusBiasMessage_Ptr = new __F__SimEvents__HippocampusBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::HippocampusBiasMessage::ice_factory()
{
    return __F__SimEvents__HippocampusBiasMessage_Ptr;
}

class __F__SimEvents__HippocampusBiasMessage__Init
{
public:

    __F__SimEvents__HippocampusBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::HippocampusBiasMessage::ice_staticId(), ::SimEvents::HippocampusBiasMessage::ice_factory());
    }

    ~__F__SimEvents__HippocampusBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::HippocampusBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__HippocampusBiasMessage__Init __F__SimEvents__HippocampusBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__HippocampusBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__HippocampusBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::HippocampusBiasMessagePtr* p = static_cast< ::SimEvents::HippocampusBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::HippocampusBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::HippocampusBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::HippocampusBiasMessage& l, const ::SimEvents::HippocampusBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::HippocampusBiasMessage& l, const ::SimEvents::HippocampusBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::HippocampusMessage::HippocampusMessage(const ::SimEvents::ObjectsStateSeq& __ice_objectsState) :
    objectsState(__ice_objectsState)
{
}

::Ice::ObjectPtr
SimEvents::HippocampusMessage::ice_clone() const
{
    ::SimEvents::HippocampusMessagePtr __p = new ::SimEvents::HippocampusMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__HippocampusMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::HippocampusMessage"
};

bool
SimEvents::HippocampusMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__HippocampusMessage_ids, __SimEvents__HippocampusMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::HippocampusMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__HippocampusMessage_ids[0], &__SimEvents__HippocampusMessage_ids[3]);
}

const ::std::string&
SimEvents::HippocampusMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__HippocampusMessage_ids[2];
}

const ::std::string&
SimEvents::HippocampusMessage::ice_staticId()
{
    return __SimEvents__HippocampusMessage_ids[2];
}

void
SimEvents::HippocampusMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    if(objectsState.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::SimEvents::__writeObjectsStateSeq(__os, &objectsState[0], &objectsState[0] + objectsState.size());
    }
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::HippocampusMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::SimEvents::__readObjectsStateSeq(__is, objectsState);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::HippocampusMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::HippocampusMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::HippocampusMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::HippocampusMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__HippocampusMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::HippocampusMessage::ice_staticId());
        return new ::SimEvents::HippocampusMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__HippocampusMessage_Ptr = new __F__SimEvents__HippocampusMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::HippocampusMessage::ice_factory()
{
    return __F__SimEvents__HippocampusMessage_Ptr;
}

class __F__SimEvents__HippocampusMessage__Init
{
public:

    __F__SimEvents__HippocampusMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::HippocampusMessage::ice_staticId(), ::SimEvents::HippocampusMessage::ice_factory());
    }

    ~__F__SimEvents__HippocampusMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::HippocampusMessage::ice_staticId());
    }
};

static __F__SimEvents__HippocampusMessage__Init __F__SimEvents__HippocampusMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__HippocampusMessage__initializer() {} }
#endif

void
SimEvents::__patch__HippocampusMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::HippocampusMessagePtr* p = static_cast< ::SimEvents::HippocampusMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::HippocampusMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::HippocampusMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::HippocampusMessage& l, const ::SimEvents::HippocampusMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::HippocampusMessage& l, const ::SimEvents::HippocampusMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::PrimaryMotorCortexBiasMessage::PrimaryMotorCortexBiasMessage(const ::SimEvents::ArmPosition& __ice_armPos, bool __ice_moveArm) :
    armPos(__ice_armPos),
    moveArm(__ice_moveArm)
{
}

::Ice::ObjectPtr
SimEvents::PrimaryMotorCortexBiasMessage::ice_clone() const
{
    ::SimEvents::PrimaryMotorCortexBiasMessagePtr __p = new ::SimEvents::PrimaryMotorCortexBiasMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__PrimaryMotorCortexBiasMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::PrimaryMotorCortexBiasMessage"
};

bool
SimEvents::PrimaryMotorCortexBiasMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__PrimaryMotorCortexBiasMessage_ids, __SimEvents__PrimaryMotorCortexBiasMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::PrimaryMotorCortexBiasMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__PrimaryMotorCortexBiasMessage_ids[0], &__SimEvents__PrimaryMotorCortexBiasMessage_ids[3]);
}

const ::std::string&
SimEvents::PrimaryMotorCortexBiasMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__PrimaryMotorCortexBiasMessage_ids[2];
}

const ::std::string&
SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId()
{
    return __SimEvents__PrimaryMotorCortexBiasMessage_ids[2];
}

void
SimEvents::PrimaryMotorCortexBiasMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    armPos.__write(__os);
    __os->write(moveArm);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::PrimaryMotorCortexBiasMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    armPos.__read(__is);
    __is->read(moveArm);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::PrimaryMotorCortexBiasMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexBiasMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::PrimaryMotorCortexBiasMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexBiasMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__PrimaryMotorCortexBiasMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId());
        return new ::SimEvents::PrimaryMotorCortexBiasMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__PrimaryMotorCortexBiasMessage_Ptr = new __F__SimEvents__PrimaryMotorCortexBiasMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::PrimaryMotorCortexBiasMessage::ice_factory()
{
    return __F__SimEvents__PrimaryMotorCortexBiasMessage_Ptr;
}

class __F__SimEvents__PrimaryMotorCortexBiasMessage__Init
{
public:

    __F__SimEvents__PrimaryMotorCortexBiasMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId(), ::SimEvents::PrimaryMotorCortexBiasMessage::ice_factory());
    }

    ~__F__SimEvents__PrimaryMotorCortexBiasMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId());
    }
};

static __F__SimEvents__PrimaryMotorCortexBiasMessage__Init __F__SimEvents__PrimaryMotorCortexBiasMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__PrimaryMotorCortexBiasMessage__initializer() {} }
#endif

void
SimEvents::__patch__PrimaryMotorCortexBiasMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::PrimaryMotorCortexBiasMessagePtr* p = static_cast< ::SimEvents::PrimaryMotorCortexBiasMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::PrimaryMotorCortexBiasMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::PrimaryMotorCortexBiasMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::PrimaryMotorCortexBiasMessage& l, const ::SimEvents::PrimaryMotorCortexBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::PrimaryMotorCortexBiasMessage& l, const ::SimEvents::PrimaryMotorCortexBiasMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::PrimaryMotorCortexRelativeServoMessage::PrimaryMotorCortexRelativeServoMessage(::Ice::Int __ice_axis, ::Ice::Int __ice_change) :
    axis(__ice_axis),
    change(__ice_change)
{
}

::Ice::ObjectPtr
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_clone() const
{
    ::SimEvents::PrimaryMotorCortexRelativeServoMessagePtr __p = new ::SimEvents::PrimaryMotorCortexRelativeServoMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__PrimaryMotorCortexRelativeServoMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::PrimaryMotorCortexRelativeServoMessage"
};

bool
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__PrimaryMotorCortexRelativeServoMessage_ids, __SimEvents__PrimaryMotorCortexRelativeServoMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__PrimaryMotorCortexRelativeServoMessage_ids[0], &__SimEvents__PrimaryMotorCortexRelativeServoMessage_ids[3]);
}

const ::std::string&
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__PrimaryMotorCortexRelativeServoMessage_ids[2];
}

const ::std::string&
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId()
{
    return __SimEvents__PrimaryMotorCortexRelativeServoMessage_ids[2];
}

void
SimEvents::PrimaryMotorCortexRelativeServoMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(axis);
    __os->write(change);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::PrimaryMotorCortexRelativeServoMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(axis);
    __is->read(change);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::PrimaryMotorCortexRelativeServoMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexRelativeServoMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::PrimaryMotorCortexRelativeServoMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexRelativeServoMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__PrimaryMotorCortexRelativeServoMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId());
        return new ::SimEvents::PrimaryMotorCortexRelativeServoMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__PrimaryMotorCortexRelativeServoMessage_Ptr = new __F__SimEvents__PrimaryMotorCortexRelativeServoMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_factory()
{
    return __F__SimEvents__PrimaryMotorCortexRelativeServoMessage_Ptr;
}

class __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__Init
{
public:

    __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId(), ::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_factory());
    }

    ~__F__SimEvents__PrimaryMotorCortexRelativeServoMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId());
    }
};

static __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__Init __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__initializer() {} }
#endif

void
SimEvents::__patch__PrimaryMotorCortexRelativeServoMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::PrimaryMotorCortexRelativeServoMessagePtr* p = static_cast< ::SimEvents::PrimaryMotorCortexRelativeServoMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::PrimaryMotorCortexRelativeServoMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::PrimaryMotorCortexRelativeServoMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::PrimaryMotorCortexRelativeServoMessage& l, const ::SimEvents::PrimaryMotorCortexRelativeServoMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::PrimaryMotorCortexRelativeServoMessage& l, const ::SimEvents::PrimaryMotorCortexRelativeServoMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_clone() const
{
    ::SimEvents::PrimaryMotorCortexResetEncodersMessagePtr __p = new ::SimEvents::PrimaryMotorCortexResetEncodersMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__PrimaryMotorCortexResetEncodersMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::PrimaryMotorCortexResetEncodersMessage"
};

bool
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__PrimaryMotorCortexResetEncodersMessage_ids, __SimEvents__PrimaryMotorCortexResetEncodersMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__PrimaryMotorCortexResetEncodersMessage_ids[0], &__SimEvents__PrimaryMotorCortexResetEncodersMessage_ids[3]);
}

const ::std::string&
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__PrimaryMotorCortexResetEncodersMessage_ids[2];
}

const ::std::string&
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId()
{
    return __SimEvents__PrimaryMotorCortexResetEncodersMessage_ids[2];
}

void
SimEvents::PrimaryMotorCortexResetEncodersMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::PrimaryMotorCortexResetEncodersMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::PrimaryMotorCortexResetEncodersMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexResetEncodersMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::PrimaryMotorCortexResetEncodersMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexResetEncodersMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__PrimaryMotorCortexResetEncodersMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId());
        return new ::SimEvents::PrimaryMotorCortexResetEncodersMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__PrimaryMotorCortexResetEncodersMessage_Ptr = new __F__SimEvents__PrimaryMotorCortexResetEncodersMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_factory()
{
    return __F__SimEvents__PrimaryMotorCortexResetEncodersMessage_Ptr;
}

class __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__Init
{
public:

    __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId(), ::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_factory());
    }

    ~__F__SimEvents__PrimaryMotorCortexResetEncodersMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId());
    }
};

static __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__Init __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__initializer() {} }
#endif

void
SimEvents::__patch__PrimaryMotorCortexResetEncodersMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::PrimaryMotorCortexResetEncodersMessagePtr* p = static_cast< ::SimEvents::PrimaryMotorCortexResetEncodersMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::PrimaryMotorCortexResetEncodersMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::PrimaryMotorCortexResetEncodersMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::PrimaryMotorCortexResetEncodersMessage& l, const ::SimEvents::PrimaryMotorCortexResetEncodersMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::PrimaryMotorCortexResetEncodersMessage& l, const ::SimEvents::PrimaryMotorCortexResetEncodersMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::PrimaryMotorCortexMessage::PrimaryMotorCortexMessage(bool __ice_targetReached) :
    targetReached(__ice_targetReached)
{
}

::Ice::ObjectPtr
SimEvents::PrimaryMotorCortexMessage::ice_clone() const
{
    ::SimEvents::PrimaryMotorCortexMessagePtr __p = new ::SimEvents::PrimaryMotorCortexMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__PrimaryMotorCortexMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::PrimaryMotorCortexMessage"
};

bool
SimEvents::PrimaryMotorCortexMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__PrimaryMotorCortexMessage_ids, __SimEvents__PrimaryMotorCortexMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::PrimaryMotorCortexMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__PrimaryMotorCortexMessage_ids[0], &__SimEvents__PrimaryMotorCortexMessage_ids[3]);
}

const ::std::string&
SimEvents::PrimaryMotorCortexMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__PrimaryMotorCortexMessage_ids[2];
}

const ::std::string&
SimEvents::PrimaryMotorCortexMessage::ice_staticId()
{
    return __SimEvents__PrimaryMotorCortexMessage_ids[2];
}

void
SimEvents::PrimaryMotorCortexMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(targetReached);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::PrimaryMotorCortexMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(targetReached);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::PrimaryMotorCortexMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::PrimaryMotorCortexMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::PrimaryMotorCortexMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__PrimaryMotorCortexMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::PrimaryMotorCortexMessage::ice_staticId());
        return new ::SimEvents::PrimaryMotorCortexMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__PrimaryMotorCortexMessage_Ptr = new __F__SimEvents__PrimaryMotorCortexMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::PrimaryMotorCortexMessage::ice_factory()
{
    return __F__SimEvents__PrimaryMotorCortexMessage_Ptr;
}

class __F__SimEvents__PrimaryMotorCortexMessage__Init
{
public:

    __F__SimEvents__PrimaryMotorCortexMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::PrimaryMotorCortexMessage::ice_staticId(), ::SimEvents::PrimaryMotorCortexMessage::ice_factory());
    }

    ~__F__SimEvents__PrimaryMotorCortexMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::PrimaryMotorCortexMessage::ice_staticId());
    }
};

static __F__SimEvents__PrimaryMotorCortexMessage__Init __F__SimEvents__PrimaryMotorCortexMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__PrimaryMotorCortexMessage__initializer() {} }
#endif

void
SimEvents::__patch__PrimaryMotorCortexMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::PrimaryMotorCortexMessagePtr* p = static_cast< ::SimEvents::PrimaryMotorCortexMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::PrimaryMotorCortexMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::PrimaryMotorCortexMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::PrimaryMotorCortexMessage& l, const ::SimEvents::PrimaryMotorCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::PrimaryMotorCortexMessage& l, const ::SimEvents::PrimaryMotorCortexMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::GUIInputMessage::GUIInputMessage(const ::std::string& __ice_msg, bool __ice_rollDice) :
    msg(__ice_msg),
    rollDice(__ice_rollDice)
{
}

::Ice::ObjectPtr
SimEvents::GUIInputMessage::ice_clone() const
{
    ::SimEvents::GUIInputMessagePtr __p = new ::SimEvents::GUIInputMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__GUIInputMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::GUIInputMessage"
};

bool
SimEvents::GUIInputMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__GUIInputMessage_ids, __SimEvents__GUIInputMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::GUIInputMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__GUIInputMessage_ids[0], &__SimEvents__GUIInputMessage_ids[3]);
}

const ::std::string&
SimEvents::GUIInputMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__GUIInputMessage_ids[2];
}

const ::std::string&
SimEvents::GUIInputMessage::ice_staticId()
{
    return __SimEvents__GUIInputMessage_ids[2];
}

void
SimEvents::GUIInputMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(msg);
    __os->write(rollDice);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::GUIInputMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(msg);
    __is->read(rollDice);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::GUIInputMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::GUIInputMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::GUIInputMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::GUIInputMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__GUIInputMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::GUIInputMessage::ice_staticId());
        return new ::SimEvents::GUIInputMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__GUIInputMessage_Ptr = new __F__SimEvents__GUIInputMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::GUIInputMessage::ice_factory()
{
    return __F__SimEvents__GUIInputMessage_Ptr;
}

class __F__SimEvents__GUIInputMessage__Init
{
public:

    __F__SimEvents__GUIInputMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::GUIInputMessage::ice_staticId(), ::SimEvents::GUIInputMessage::ice_factory());
    }

    ~__F__SimEvents__GUIInputMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::GUIInputMessage::ice_staticId());
    }
};

static __F__SimEvents__GUIInputMessage__Init __F__SimEvents__GUIInputMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__GUIInputMessage__initializer() {} }
#endif

void
SimEvents::__patch__GUIInputMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::GUIInputMessagePtr* p = static_cast< ::SimEvents::GUIInputMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::GUIInputMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::GUIInputMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::GUIInputMessage& l, const ::SimEvents::GUIInputMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::GUIInputMessage& l, const ::SimEvents::GUIInputMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

SimEvents::GUIOutputMessage::GUIOutputMessage(::Ice::Int __ice_key, const ::ImageIceMod::Point2DIce& __ice_loc, ::Ice::Int __ice_dice) :
    key(__ice_key),
    loc(__ice_loc),
    dice(__ice_dice)
{
}

::Ice::ObjectPtr
SimEvents::GUIOutputMessage::ice_clone() const
{
    ::SimEvents::GUIOutputMessagePtr __p = new ::SimEvents::GUIOutputMessage(*this);
    return __p;
}

static const ::std::string __SimEvents__GUIOutputMessage_ids[3] =
{
    "::Ice::Object",
    "::SimEvents::EventMessage",
    "::SimEvents::GUIOutputMessage"
};

bool
SimEvents::GUIOutputMessage::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__SimEvents__GUIOutputMessage_ids, __SimEvents__GUIOutputMessage_ids + 3, _s);
}

::std::vector< ::std::string>
SimEvents::GUIOutputMessage::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__SimEvents__GUIOutputMessage_ids[0], &__SimEvents__GUIOutputMessage_ids[3]);
}

const ::std::string&
SimEvents::GUIOutputMessage::ice_id(const ::Ice::Current&) const
{
    return __SimEvents__GUIOutputMessage_ids[2];
}

const ::std::string&
SimEvents::GUIOutputMessage::ice_staticId()
{
    return __SimEvents__GUIOutputMessage_ids[2];
}

void
SimEvents::GUIOutputMessage::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(key);
    loc.__write(__os);
    __os->write(dice);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__write(__os);
#else
    ::SimEvents::EventMessage::__write(__os);
#endif
}

void
SimEvents::GUIOutputMessage::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(key);
    loc.__read(__is);
    __is->read(dice);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EventMessage::__read(__is, true);
#else
    ::SimEvents::EventMessage::__read(__is, true);
#endif
}

void
SimEvents::GUIOutputMessage::__write(const ::Ice::OutputStreamPtr&) const
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::GUIOutputMessage was not generated with stream support";
    throw ex;
}

void
SimEvents::GUIOutputMessage::__read(const ::Ice::InputStreamPtr&, bool)
{
    Ice::MarshalException ex(__FILE__, __LINE__);
    ex.reason = "type SimEvents::GUIOutputMessage was not generated with stream support";
    throw ex;
}

class __F__SimEvents__GUIOutputMessage : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::SimEvents::GUIOutputMessage::ice_staticId());
        return new ::SimEvents::GUIOutputMessage;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__SimEvents__GUIOutputMessage_Ptr = new __F__SimEvents__GUIOutputMessage;

const ::Ice::ObjectFactoryPtr&
SimEvents::GUIOutputMessage::ice_factory()
{
    return __F__SimEvents__GUIOutputMessage_Ptr;
}

class __F__SimEvents__GUIOutputMessage__Init
{
public:

    __F__SimEvents__GUIOutputMessage__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::SimEvents::GUIOutputMessage::ice_staticId(), ::SimEvents::GUIOutputMessage::ice_factory());
    }

    ~__F__SimEvents__GUIOutputMessage__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::SimEvents::GUIOutputMessage::ice_staticId());
    }
};

static __F__SimEvents__GUIOutputMessage__Init __F__SimEvents__GUIOutputMessage__i;

#ifdef __APPLE__
extern "C" { void __F__SimEvents__GUIOutputMessage__initializer() {} }
#endif

void
SimEvents::__patch__GUIOutputMessagePtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::SimEvents::GUIOutputMessagePtr* p = static_cast< ::SimEvents::GUIOutputMessagePtr*>(__addr);
    assert(p);
    *p = ::SimEvents::GUIOutputMessagePtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::SimEvents::GUIOutputMessage::ice_staticId(), v->ice_id());
    }
}

bool
SimEvents::operator==(const ::SimEvents::GUIOutputMessage& l, const ::SimEvents::GUIOutputMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
SimEvents::operator<(const ::SimEvents::GUIOutputMessage& l, const ::SimEvents::GUIOutputMessage& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}