增加了连接战斗服ICE的Demo

Config/ice.config

@@ -0,0 +1,47 @@
+zoneManager.Proxy=zoneManager:tcp -h localhost -p 3910
+XmdsManager.Proxy=XmdsManager:tcp -h localhost -p 3910
+#Ice.Default.Host
+Ice.ACM.Heartbeat=3
+Ice.ACM.Close=0
+
+#
+# Warn about connection exceptions
+#
+Ice.Warn.Connections=1
+
+#
+# Network Tracing
+#
+# 0 = no network tracing
+# 1 = trace connection establishment and closure
+# 2 = like 1, but more detailed
+# 3 = like 2, but also trace data transfer
+#
+#Ice.Trace.Network=1
+
+#
+# Protocol Tracing
+#
+# 0 = no protocol tracing
+# 1 = trace protocol messages
+#
+#Ice.Trace.Protocol=1
+Ice.Trace.Network=1
+Ice.Trace.Retry=2
+
+#
+# Security Tracing
+#
+# 0 = no security tracing
+# 1 = trace messages
+#
+#IceSSL.Trace.Security=1
+
+#
+# SSL Configuration
+#
+#Ice.Plugin.IceSSL=IceSSL:IceSSL.PluginFactory
+#IceSSL.DefaultDir=../../../certs
+#IceSSL.CAs=cacert.pem
+#IceSSL.CertFile=client.p12
+#IceSSL.Password=password

DotNet/Hotfix/Demo/EntryEvent2_InitServer.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Net;
+using ET;
+
+namespace ET.Server
+{
+    [Event(SceneType.Process)]
+    public class EntryEvent2_InitServer: AEvent<ET.EventType.EntryEvent2>
+    {
+        protected override async ETTask Run(Scene scene, ET.EventType.EntryEvent2 args)
+        {
+            // 发送普通actor消息
+            Root.Instance.Scene.AddComponent<ActorMessageSenderComponent>();
+            // 发送location actor消息
+            Root.Instance.Scene.AddComponent<ActorLocationSenderComponent>();
+            // 访问location server的组件
+            Root.Instance.Scene.AddComponent<LocationProxyComponent>();
+            Root.Instance.Scene.AddComponent<ActorMessageDispatcherComponent>();
+            Root.Instance.Scene.AddComponent<ServerSceneManagerComponent>();
+            Root.Instance.Scene.AddComponent<RobotCaseComponent>();
+
+            Root.Instance.Scene.AddComponent<NavmeshComponent>();
+
+            StartProcessConfig processConfig = StartProcessConfigCategory.Instance.Get(Options.Instance.Process);
+            Log.Debug($"AppType: {Options.Instance.AppType}");
+            switch (Options.Instance.AppType)
+            {
+                case AppType.Server:
+                {
+                    StartMachineConfig startMachineConfig = WatcherHelper.GetThisMachineConfig();
+                    //初始化游戏服全局参数
+                    Global.GameServerId = startMachineConfig.GameServerId;
+                    Global.GameServerUUID = Guid.NewGuid().ToString();
+
+                    //GameServer添加战斗服的Ice会话组件
+                    Root.Instance.Scene.AddComponent<BattleIceAgentComponent>();
+                        
+                    Root.Instance.Scene.AddComponent<NetInnerComponent, IPEndPoint>(processConfig.InnerIPPort);
+
+                    var processScenes = StartSceneConfigCategory.Instance.GetByProcess(Options.Instance.Process);
+                    foreach (StartSceneConfig startConfig in processScenes)
+                    {
+                        await SceneFactory.CreateServerScene(ServerSceneManagerComponent.Instance, startConfig.Id, startConfig.InstanceId, startConfig.Zone, startConfig.Name,
+                            startConfig.Type, startConfig);
+                    }
+                    break;
+                }
+                case AppType.Watcher:
+                {
+                    StartMachineConfig startMachineConfig = WatcherHelper.GetThisMachineConfig();
+                    WatcherComponent watcherComponent = Root.Instance.Scene.AddComponent<WatcherComponent>();
+                    watcherComponent.Start(Options.Instance.CreateScenes);
+                    Root.Instance.Scene.AddComponent<NetInnerComponent, IPEndPoint>(NetworkHelper.ToIPEndPoint($"{startMachineConfig.InnerIP}:{startMachineConfig.WatcherPort}"));
+                    break;
+                }
+                case AppType.GameTool:
+                    break;
+            }
+
+            if (Options.Instance.Console == 1)
+            {
+                Root.Instance.Scene.AddComponent<ConsoleComponent>();
+            }
+        }
+    }
+}

DotNet/Hotfix/IceBattle/BattleIceAgentComponentSystem.cs

@@ -0,0 +1,93 @@
+using Ice;
+using System;
+using System.Threading.Tasks;
+
+namespace ET.Server
+{
+    [FriendOf(typeof(BattleIceAgentComponent))]
+    public static class BattleIceAgentComponentSystem
+    {
+        public class BattleIceAgentComponentAwakeSystem : AwakeSystem<BattleIceAgentComponent>
+        {
+            protected override void Awake(BattleIceAgentComponent self)
+            {
+                BattleIceAgentComponent.Instance = self;
+
+                self.IceApp = new IceApp();
+                self.IceApp.main(new string[0], "../Config/ice.config");
+            }
+        }
+
+        public class BattleIceAgentComponentDestroySystem : DestroySystem<BattleIceAgentComponent>
+        {
+            protected override void Destroy(BattleIceAgentComponent self)
+            {
+                Ice.Application.communicator().Dispose();
+            }
+        }
+
+        [ObjectSystem]
+        [FriendOf(typeof(BattleIceAgentComponent))]
+        public class IceApp : Ice.Application
+        {
+            public override int run(string[] args)
+            {
+                try
+                {
+                    var ZoneIce = BattleIce.ZoneManagerPrxHelper.checkedCast(communicator().propertyToProxy("zoneManager.Proxy"));
+                    if (ZoneIce == null)
+                    {
+                        Log.Error("not found ice proxy: zoneManager");
+                        return 1;
+                    }
+                    BattleIceAgentComponent.Instance.IceZoneManager = ZoneIce;
+                    Log.Debug("got zoneManager.Proxy");
+                    ZoneIce.ice_invocationTimeout(15);
+
+                    Ice.ObjectAdapter adapter = communicator().createObjectAdapter("");
+                    var prx = adapter.add(new ZoneManagerCallback(), communicator().stringToIdentity("bs-" + Global.GameServerId));
+                    ZoneIce.ice_getCachedConnection().setAdapter(adapter);
+                    ZoneIce.setCallback(prx.ice_getIdentity(), Global.GameServerUUID);
+
+                    //测试一下ice接口
+                    var res = ZoneIce.registerGameServer(Global.GameServerId, Global.GameServerId);
+                    Log.Debug($"registerGameServer ret:  {res}");
+                }
+                catch(Ice.Exception e)
+                {
+                    Log.Error(e.Message); 
+                    return 1;
+                }
+
+                try
+                {
+                    var XmdsIce = BattleIce.XmdsManagerPrxHelper.checkedCast(communicator().propertyToProxy("XmdsManager.Proxy"));
+                    if (XmdsIce == null)
+                    {
+                        Log.Error("not found ice proxy: XmdsManager");
+                        return 1;
+                    }
+                    Log.Debug("got XmdsManager.Proxy");
+                    BattleIceAgentComponent.Instance.IceXmdsManager = XmdsIce;
+                    XmdsIce.ice_invocationTimeout(15);
+                }
+                catch(Ice.Exception e)
+                {
+                    Log.Error(e.Message);
+                    return 2;
+                }
+
+                return 0;
+            }
+        }
+
+        [ObjectSystem]
+        public class ZoneManagerCallback : BattleIce.ZoneManagerCallbackDisp_
+        {
+            public override void eventNotify(string eventType, string msg, Current current__)
+            {
+                Log.Debug($"battleServer zone notify: type({eventType}), msg({msg})");
+            }
+        }
+    }
+}

DotNet/Model/IceGenerate/XmdsManager.cs

@@ -0,0 +1,12142 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 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.6.4
+//
+// <auto-generated>
+//
+// Generated from file `XmdsManager.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+
+using _System = global::System;
+using _Microsoft = global::Microsoft;
+
+#pragma warning disable 1591
+
+namespace IceCompactId
+{
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class FinishPickItem : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public string itemIcon;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int quality;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int num;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public string instanceId;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int objectId;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public FinishPickItem()
+        {
+            itemIcon = "";
+            instanceId = "";
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public FinishPickItem(string itemIcon, int quality, int num, string instanceId, int objectId)
+        {
+            this.itemIcon = itemIcon;
+            this.quality = quality;
+            this.num = num;
+            this.instanceId = instanceId;
+            this.objectId = objectId;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::FinishPickItem",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeString(itemIcon);
+            os__.writeInt(quality);
+            os__.writeInt(num);
+            os__.writeString(instanceId);
+            os__.writeInt(objectId);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            itemIcon = is__.readString();
+            quality = is__.readInt();
+            num = is__.readInt();
+            instanceId = is__.readString();
+            objectId = is__.readInt();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class PlayerPKInfoData : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkMode;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkValue;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkLevel;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public PlayerPKInfoData()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public PlayerPKInfoData(int pkMode, int pkValue, int pkLevel)
+        {
+            this.pkMode = pkMode;
+            this.pkValue = pkValue;
+            this.pkLevel = pkLevel;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::PlayerPKInfoData",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeInt(pkMode);
+            os__.writeInt(pkValue);
+            os__.writeInt(pkLevel);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            pkMode = is__.readInt();
+            pkValue = is__.readInt();
+            pkLevel = is__.readInt();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class CanTalkWithNpc : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int templateId;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public bool canTalk;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public CanTalkWithNpc()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public CanTalkWithNpc(int templateId, bool canTalk)
+        {
+            this.templateId = templateId;
+            this.canTalk = canTalk;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::CanTalkWithNpc",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeInt(templateId);
+            os__.writeBool(canTalk);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            templateId = is__.readInt();
+            canTalk = is__.readBool();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class RefreshPlayerPropertyChange : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public string key;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int changeType;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int valueType;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int value;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int duration;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public long timestamp;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public RefreshPlayerPropertyChange()
+        {
+            key = "";
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public RefreshPlayerPropertyChange(string key, int changeType, int valueType, int value, int duration, long timestamp)
+        {
+            this.key = key;
+            this.changeType = changeType;
+            this.valueType = valueType;
+            this.value = value;
+            this.duration = duration;
+            this.timestamp = timestamp;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::RefreshPlayerPropertyChange",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeString(key);
+            os__.writeInt(changeType);
+            os__.writeInt(valueType);
+            os__.writeInt(value);
+            os__.writeInt(duration);
+            os__.writeLong(timestamp);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            key = is__.readString();
+            changeType = is__.readInt();
+            valueType = is__.readInt();
+            value = is__.readInt();
+            duration = is__.readInt();
+            timestamp = is__.readLong();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class SkillDataICE : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int skillId;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public long skillTime;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public SkillDataICE()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public SkillDataICE(int skillId, long skillTime)
+        {
+            this.skillId = skillId;
+            this.skillTime = skillTime;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::SkillDataICE",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeInt(skillId);
+            os__.writeLong(skillTime);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            skillId = is__.readInt();
+            skillTime = is__.readLong();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class GetPlayerData : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public float x;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public float y;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public float direction;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int hp;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int mp;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkMode;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkValue;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int pkLevel;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public BattleIce.SkillDataICE[] skillData;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int combatState;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public GetPlayerData()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public GetPlayerData(float x, float y, float direction, int hp, int mp, int pkMode, int pkValue, int pkLevel, BattleIce.SkillDataICE[] skillData, int combatState)
+        {
+            this.x = x;
+            this.y = y;
+            this.direction = direction;
+            this.hp = hp;
+            this.mp = mp;
+            this.pkMode = pkMode;
+            this.pkValue = pkValue;
+            this.pkLevel = pkLevel;
+            this.skillData = skillData;
+            this.combatState = combatState;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::GetPlayerData",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeFloat(x);
+            os__.writeFloat(y);
+            os__.writeFloat(direction);
+            os__.writeInt(hp);
+            os__.writeInt(mp);
+            os__.writeInt(pkMode);
+            os__.writeInt(pkValue);
+            os__.writeInt(pkLevel);
+            BattleIce.SkillDataSeqHelper.write(os__, skillData);
+            os__.writeInt(combatState);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            x = is__.readFloat();
+            y = is__.readFloat();
+            direction = is__.readFloat();
+            hp = is__.readInt();
+            mp = is__.readInt();
+            pkMode = is__.readInt();
+            pkValue = is__.readInt();
+            pkLevel = is__.readInt();
+            skillData = BattleIce.SkillDataSeqHelper.read(is__);
+            combatState = is__.readInt();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+#if !SILVERLIGHT
+    [_System.Serializable]
+#endif
+    public partial class CanTalkWithNpcResult : Ice.Object
+    {
+        #region Slice data members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public int templateId;
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public bool canTalk;
+
+        #endregion
+
+        #region Constructors
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public CanTalkWithNpcResult()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public CanTalkWithNpcResult(int templateId, bool canTalk)
+        {
+            this.templateId = templateId;
+            this.canTalk = canTalk;
+        }
+
+        #endregion
+
+        #region Slice type-related members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static readonly string[] ids__ = 
+        {
+            "::BattleIce::CanTalkWithNpcResult",
+            "::Ice::Object"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_ping(Ice.Current current__)
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id()
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request, Ice.DispatchInterceptorAsyncCallback cb)
+        {
+            IceInternal.Incoming inc = (IceInternal.Incoming)request;
+            if(cb != null)
+            {
+                inc.push(cb);
+            }
+            try
+            {
+                inc.startOver();
+                return dispatch__(inc, inc.getCurrent());
+            }
+            finally
+            {
+                if(cb != null)
+                {
+                    inc.pop();
+                }
+            }
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus ice_dispatch(Ice.Request request)
+        {
+            return ice_dispatch(request, null);
+        }
+
+        private static string[] all__ =
+        {
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_preMarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void ice_postUnmarshal()
+        {
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteObject(null);
+            writeImpl__(os__);
+            os__.endWriteObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(IceInternal.BasicStream is__)
+        {
+            is__.startReadObject();
+            readImpl__(is__);
+            is__.endReadObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void write__(Ice.OutputStream outS__)
+        {
+            outS__.startObject(null);
+            writeImpl__(outS__);
+            outS__.endObject();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public virtual void read__(Ice.InputStream inS__)
+        {
+            inS__.startObject();
+            readImpl__(inS__);
+            inS__.endObject(false);
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.writeInt(templateId);
+            os__.writeBool(canTalk);
+            os__.endWriteSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            templateId = is__.readInt();
+            canTalk = is__.readBool();
+            is__.endReadSlice();
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void writeImpl__(Ice.OutputStream os__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        protected virtual void readImpl__(Ice.InputStream is__)
+        {
+            throw new Ice.MarshalException("class was not generated with stream support");
+        }
+
+        #endregion
+
+        #region ICloneable members
+
+        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+        public object Clone()
+        {
+            return MemberwiseClone();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+    public partial interface XmdsManager : Ice.Object, XmdsManagerOperations_, XmdsManagerOperationsNC_
+    {
+    }
+}
+
+namespace BattleIce
+{
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_notifyBattleServer();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getZoneStaticData(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getZoneRegions(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getBornPlace(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getAllUnitInfo(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getAllNpcInfo(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getAllPlayerUUID(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getPlayerData(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_onMonsterDiedDrops();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_helpRevivePlayer();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_revivePlayer();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshSummonMount();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerBasicData();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerTeamData();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerRemainBagCountData();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerRemainTeamBagCountData();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPetBaseInfoChange();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPetDataChange(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerBattleEffect();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_addPlayerAtt();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerSkill();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_playerChangeSkill();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerAvatar();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getPlayerPKInfoData(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getPlayerSkillCDTime(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_canTalkWithNpc(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPropertyChange();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPKMode(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPKValue();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPKLevel();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_onFinishPickItem();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPetSkillChange();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_canUseItem(bool ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_transferToPointPos(bool ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPetPropertyChange();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getPlayerPetData(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_triggrBattleFunction();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_addUnits(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshPlayerPetFollowModeChange();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_playerReady();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_refreshTeamData();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_autoBattle();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getPlayerStatistic(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_getInstanceStatistic(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_addUnit(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_removeUnit();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_removePointUnit();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_removeItem();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_changePlayerState();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_playerChuanGong();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_XmdsManager_mountainKingRefreshNotify();
+}
+
+namespace BattleIce
+{
+    /// <summary>
+    /// onFinishPickItem
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface FinishPickItemPrx : Ice.ObjectPrx
+    {
+    }
+
+    /// <summary>
+    /// getPlayerPKInfoData
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface PlayerPKInfoDataPrx : Ice.ObjectPrx
+    {
+    }
+
+    /// <summary>
+    /// canTalkWithNpc
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface CanTalkWithNpcPrx : Ice.ObjectPrx
+    {
+    }
+
+    /// <summary>
+    /// refreshPlayerPropertyChange
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface RefreshPlayerPropertyChangePrx : Ice.ObjectPrx
+    {
+    }
+
+    /// <summary>
+    /// getPlayerData
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface SkillDataICEPrx : Ice.ObjectPrx
+    {
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface GetPlayerDataPrx : Ice.ObjectPrx
+    {
+    }
+
+    /// <summary>
+    /// canTalkWithNpc
+    /// </summary>
+    
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface CanTalkWithNpcResultPrx : Ice.ObjectPrx
+    {
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface XmdsManagerPrx : Ice.ObjectPrx
+    {
+        void notifyBattleServer(string instanceId, string name, string data);
+
+        void notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_notifyBattleServer> begin_notifyBattleServer(string instanceId, string name, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_notifyBattleServer> begin_notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_notifyBattleServer(string instanceId, string name, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_notifyBattleServer(Ice.AsyncResult r__);
+
+        string getZoneStaticData(string instanceId);
+
+        string getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneStaticData> begin_getZoneStaticData(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneStaticData> begin_getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getZoneStaticData(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getZoneStaticData(Ice.AsyncResult r__);
+
+        string getZoneRegions(string instanceId);
+
+        string getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneRegions> begin_getZoneRegions(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneRegions> begin_getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getZoneRegions(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getZoneRegions(Ice.AsyncResult r__);
+
+        string getBornPlace(string instanceId, int areaId, string pointId);
+
+        string getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getBornPlace> begin_getBornPlace(string instanceId, int areaId, string pointId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getBornPlace> begin_getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getBornPlace(string instanceId, int areaId, string pointId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getBornPlace(Ice.AsyncResult r__);
+
+        string getAllUnitInfo(string instanceId);
+
+        string getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllUnitInfo> begin_getAllUnitInfo(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllUnitInfo> begin_getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getAllUnitInfo(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getAllUnitInfo(Ice.AsyncResult r__);
+
+        string getAllNpcInfo(string instanceId);
+
+        string getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllNpcInfo> begin_getAllNpcInfo(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllNpcInfo> begin_getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getAllNpcInfo(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getAllNpcInfo(Ice.AsyncResult r__);
+
+        string getAllPlayerUUID();
+
+        string getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllPlayerUUID> begin_getAllPlayerUUID();
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllPlayerUUID> begin_getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getAllPlayerUUID(Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getAllPlayerUUID(Ice.AsyncResult r__);
+
+        string getPlayerData(string playerId, bool changeArea);
+
+        string getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerData> begin_getPlayerData(string playerId, bool changeArea);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerData> begin_getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getPlayerData(string playerId, bool changeArea, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getPlayerData(Ice.AsyncResult r__);
+
+        void onMonsterDiedDrops(string instanceId, string data);
+
+        void onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> begin_onMonsterDiedDrops(string instanceId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> begin_onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_onMonsterDiedDrops(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_onMonsterDiedDrops(Ice.AsyncResult r__);
+
+        void helpRevivePlayer(string playerId, string revivePlayerId, int time);
+
+        void helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_helpRevivePlayer> begin_helpRevivePlayer(string playerId, string revivePlayerId, int time);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_helpRevivePlayer> begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_helpRevivePlayer(Ice.AsyncResult r__);
+
+        void revivePlayer(string playerId, string data);
+
+        void revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_revivePlayer> begin_revivePlayer(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_revivePlayer> begin_revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_revivePlayer(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_revivePlayer(Ice.AsyncResult r__);
+
+        void refreshSummonMount(string playerId, int time, int isUp);
+
+        void refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshSummonMount> begin_refreshSummonMount(string playerId, int time, int isUp);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshSummonMount> begin_refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshSummonMount(string playerId, int time, int isUp, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshSummonMount(Ice.AsyncResult r__);
+
+        void refreshPlayerBasicData(string playerId, string basic);
+
+        void refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> begin_refreshPlayerBasicData(string playerId, string basic);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> begin_refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerBasicData(string playerId, string basic, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerBasicData(Ice.AsyncResult r__);
+
+        void refreshPlayerTeamData(string playerId, string uuidList);
+
+        void refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> begin_refreshPlayerTeamData(string playerId, string uuidList);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> begin_refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerTeamData(string playerId, string uuidList, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerTeamData(Ice.AsyncResult r__);
+
+        void refreshPlayerRemainBagCountData(string playerId, int remainCount);
+
+        void refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> begin_refreshPlayerRemainBagCountData(string playerId, int remainCount);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerRemainBagCountData(Ice.AsyncResult r__);
+
+        void refreshPlayerRemainTeamBagCountData(string playerId, int remainCount);
+
+        void refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerRemainTeamBagCountData(Ice.AsyncResult r__);
+
+        void refreshPlayerPetBaseInfoChange(string playerId, string data);
+
+        void refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> begin_refreshPlayerPetBaseInfoChange(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> begin_refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPetBaseInfoChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPetBaseInfoChange(Ice.AsyncResult r__);
+
+        int refreshPlayerPetDataChange(string playerId, int type, string data);
+
+        int refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> begin_refreshPlayerPetDataChange(string playerId, int type, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> begin_refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPetDataChange(string playerId, int type, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_refreshPlayerPetDataChange(Ice.AsyncResult r__);
+
+        void refreshPlayerBattleEffect(string playerId, string effects);
+
+        void refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> begin_refreshPlayerBattleEffect(string playerId, string effects);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> begin_refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerBattleEffect(string playerId, string effects, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerBattleEffect(Ice.AsyncResult r__);
+
+        void addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value);
+
+        void addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addPlayerAtt> begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addPlayerAtt> begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_addPlayerAtt(Ice.AsyncResult r__);
+
+        void refreshPlayerSkill(string playerId, int operateID, string skills);
+
+        void refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerSkill> begin_refreshPlayerSkill(string playerId, int operateID, string skills);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerSkill> begin_refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerSkill(string playerId, int operateID, string skills, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerSkill(Ice.AsyncResult r__);
+
+        void playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data);
+
+        void playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChangeSkill> begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChangeSkill> begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerChangeSkill(Ice.AsyncResult r__);
+
+        void refreshPlayerAvatar(string playerId, string avatars);
+
+        void refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> begin_refreshPlayerAvatar(string playerId, string avatars);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> begin_refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerAvatar(string playerId, string avatars, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerAvatar(Ice.AsyncResult r__);
+
+        string getPlayerPKInfoData(string playerId);
+
+        string getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> begin_getPlayerPKInfoData(string playerId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> begin_getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getPlayerPKInfoData(string playerId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getPlayerPKInfoData(Ice.AsyncResult r__);
+
+        string getPlayerSkillCDTime(string playerId);
+
+        string getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> begin_getPlayerSkillCDTime(string playerId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> begin_getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getPlayerSkillCDTime(string playerId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getPlayerSkillCDTime(Ice.AsyncResult r__);
+
+        string canTalkWithNpc(string playerId, int npcId);
+
+        string canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_canTalkWithNpc> begin_canTalkWithNpc(string playerId, int npcId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_canTalkWithNpc> begin_canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_canTalkWithNpc(string playerId, int npcId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_canTalkWithNpc(Ice.AsyncResult r__);
+
+        void refreshPlayerPropertyChange(string playerId, string data);
+
+        void refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> begin_refreshPlayerPropertyChange(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> begin_refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPropertyChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPropertyChange(Ice.AsyncResult r__);
+
+        int refreshPlayerPKMode(string playerId, bool isLook, int mode);
+
+        int refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> begin_refreshPlayerPKMode(string playerId, bool isLook, int mode);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_refreshPlayerPKMode(Ice.AsyncResult r__);
+
+        void refreshPlayerPKValue(string playerId, int value);
+
+        void refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> begin_refreshPlayerPKValue(string playerId, int value);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> begin_refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPKValue(string playerId, int value, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPKValue(Ice.AsyncResult r__);
+
+        void refreshPlayerPKLevel(string playerId, int level);
+
+        void refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> begin_refreshPlayerPKLevel(string playerId, int level);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> begin_refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPKLevel(string playerId, int level, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPKLevel(Ice.AsyncResult r__);
+
+        void onFinishPickItem(string playerId, string data);
+
+        void onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_onFinishPickItem> begin_onFinishPickItem(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_onFinishPickItem> begin_onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_onFinishPickItem(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_onFinishPickItem(Ice.AsyncResult r__);
+
+        void refreshPlayerPetSkillChange(string playerId, int operateID, string skills);
+
+        void refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPetSkillChange(Ice.AsyncResult r__);
+
+        bool canUseItem(string playerId);
+
+        bool canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_canUseItem> begin_canUseItem(string playerId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_canUseItem> begin_canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_canUseItem(string playerId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        bool end_canUseItem(Ice.AsyncResult r__);
+
+        bool transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction);
+
+        bool transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_transferToPointPos> begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_transferToPointPos> begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        bool end_transferToPointPos(Ice.AsyncResult r__);
+
+        void refreshPlayerPetPropertyChange(string playerId, string data);
+
+        void refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> begin_refreshPlayerPetPropertyChange(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> begin_refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPetPropertyChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPetPropertyChange(Ice.AsyncResult r__);
+
+        string getPlayerPetData(string playerId);
+
+        string getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPetData> begin_getPlayerPetData(string playerId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPetData> begin_getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getPlayerPetData(string playerId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getPlayerPetData(Ice.AsyncResult r__);
+
+        void triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6);
+
+        void triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_triggrBattleFunction> begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_triggrBattleFunction> begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_triggrBattleFunction(Ice.AsyncResult r__);
+
+        int addUnits(string instanceId, string data);
+
+        int addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnits> begin_addUnits(string instanceId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnits> begin_addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_addUnits(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_addUnits(Ice.AsyncResult r__);
+
+        void refreshPlayerPetFollowModeChange(string playerId, int mode);
+
+        void refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> begin_refreshPlayerPetFollowModeChange(string playerId, int mode);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> begin_refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshPlayerPetFollowModeChange(string playerId, int mode, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshPlayerPetFollowModeChange(Ice.AsyncResult r__);
+
+        void playerReady(string playerId);
+
+        void playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerReady> begin_playerReady(string playerId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerReady> begin_playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerReady(string playerId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerReady(Ice.AsyncResult r__);
+
+        void refreshTeamData(string playerId, string data);
+
+        void refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshTeamData> begin_refreshTeamData(string playerId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshTeamData> begin_refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_refreshTeamData(string playerId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_refreshTeamData(Ice.AsyncResult r__);
+
+        void autoBattle(string instanceId, string playerId, bool enable);
+
+        void autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_autoBattle> begin_autoBattle(string instanceId, string playerId, bool enable);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_autoBattle> begin_autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_autoBattle(string instanceId, string playerId, bool enable, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_autoBattle(Ice.AsyncResult r__);
+
+        string getPlayerStatistic(string instanceId, string playerId, int flag);
+
+        string getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerStatistic> begin_getPlayerStatistic(string instanceId, string playerId, int flag);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerStatistic> begin_getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getPlayerStatistic(string instanceId, string playerId, int flag, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getPlayerStatistic(Ice.AsyncResult r__);
+
+        string getInstanceStatistic(string instanceId);
+
+        string getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getInstanceStatistic> begin_getInstanceStatistic(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_getInstanceStatistic> begin_getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getInstanceStatistic(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getInstanceStatistic(Ice.AsyncResult r__);
+
+        int addUnit(string instanceId, int unitTemplateID, string data);
+
+        int addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnit> begin_addUnit(string instanceId, int unitTemplateID, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnit> begin_addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_addUnit(string instanceId, int unitTemplateID, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_addUnit(Ice.AsyncResult r__);
+
+        void removeUnit(string instanceId, int unitId);
+
+        void removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeUnit> begin_removeUnit(string instanceId, int unitId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeUnit> begin_removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_removeUnit(string instanceId, int unitId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_removeUnit(Ice.AsyncResult r__);
+
+        void removePointUnit(string instanceId, int unitObjectId);
+
+        void removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removePointUnit> begin_removePointUnit(string instanceId, int unitObjectId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removePointUnit> begin_removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_removePointUnit(string instanceId, int unitObjectId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_removePointUnit(Ice.AsyncResult r__);
+
+        void removeItem(string instanceId, int itemId);
+
+        void removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeItem> begin_removeItem(string instanceId, int itemId);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeItem> begin_removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_removeItem(string instanceId, int itemId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_removeItem(Ice.AsyncResult r__);
+
+        void changePlayerState(string instanceId, string playerId, byte status, int time);
+
+        void changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_changePlayerState> begin_changePlayerState(string instanceId, string playerId, byte status, int time);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_changePlayerState> begin_changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_changePlayerState(string instanceId, string playerId, byte status, int time, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_changePlayerState(Ice.AsyncResult r__);
+
+        void playerChuanGong(string instanceId, string playerIdA, string playerIdB);
+
+        void playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChuanGong> begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChuanGong> begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerChuanGong(Ice.AsyncResult r__);
+
+        void mountainKingRefreshNotify(string instanceId, string data);
+
+        void mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> begin_mountainKingRefreshNotify(string instanceId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> begin_mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_mountainKingRefreshNotify(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_mountainKingRefreshNotify(Ice.AsyncResult r__);
+    }
+}
+
+namespace BattleIce
+{
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface XmdsManagerOperations_
+    {
+        void notifyBattleServer_async(BattleIce.AMD_XmdsManager_notifyBattleServer cb__, string instanceId, string name, string data, Ice.Current current__);
+
+        void getZoneStaticData_async(BattleIce.AMD_XmdsManager_getZoneStaticData cb__, string instanceId, Ice.Current current__);
+
+        void getZoneRegions_async(BattleIce.AMD_XmdsManager_getZoneRegions cb__, string instanceId, Ice.Current current__);
+
+        void getBornPlace_async(BattleIce.AMD_XmdsManager_getBornPlace cb__, string instanceId, int areaId, string pointId, Ice.Current current__);
+
+        void getAllUnitInfo_async(BattleIce.AMD_XmdsManager_getAllUnitInfo cb__, string instanceId, Ice.Current current__);
+
+        void getAllNpcInfo_async(BattleIce.AMD_XmdsManager_getAllNpcInfo cb__, string instanceId, Ice.Current current__);
+
+        void getAllPlayerUUID_async(BattleIce.AMD_XmdsManager_getAllPlayerUUID cb__, Ice.Current current__);
+
+        void getPlayerData_async(BattleIce.AMD_XmdsManager_getPlayerData cb__, string playerId, bool changeArea, Ice.Current current__);
+
+        void onMonsterDiedDrops_async(BattleIce.AMD_XmdsManager_onMonsterDiedDrops cb__, string instanceId, string data, Ice.Current current__);
+
+        void helpRevivePlayer_async(BattleIce.AMD_XmdsManager_helpRevivePlayer cb__, string playerId, string revivePlayerId, int time, Ice.Current current__);
+
+        void revivePlayer_async(BattleIce.AMD_XmdsManager_revivePlayer cb__, string playerId, string data, Ice.Current current__);
+
+        void refreshSummonMount_async(BattleIce.AMD_XmdsManager_refreshSummonMount cb__, string playerId, int time, int isUp, Ice.Current current__);
+
+        void refreshPlayerBasicData_async(BattleIce.AMD_XmdsManager_refreshPlayerBasicData cb__, string playerId, string basic, Ice.Current current__);
+
+        void refreshPlayerTeamData_async(BattleIce.AMD_XmdsManager_refreshPlayerTeamData cb__, string playerId, string uuidList, Ice.Current current__);
+
+        void refreshPlayerRemainBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainBagCountData cb__, string playerId, int remainCount, Ice.Current current__);
+
+        void refreshPlayerRemainTeamBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__, string playerId, int remainCount, Ice.Current current__);
+
+        void refreshPlayerPetBaseInfoChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__, string playerId, string data, Ice.Current current__);
+
+        void refreshPlayerPetDataChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetDataChange cb__, string playerId, int type, string data, Ice.Current current__);
+
+        void refreshPlayerBattleEffect_async(BattleIce.AMD_XmdsManager_refreshPlayerBattleEffect cb__, string playerId, string effects, Ice.Current current__);
+
+        void addPlayerAtt_async(BattleIce.AMD_XmdsManager_addPlayerAtt cb__, string playerId, string notifyPlayerIds, string key, int value, Ice.Current current__);
+
+        void refreshPlayerSkill_async(BattleIce.AMD_XmdsManager_refreshPlayerSkill cb__, string playerId, int operateID, string skills, Ice.Current current__);
+
+        void playerChangeSkill_async(BattleIce.AMD_XmdsManager_playerChangeSkill cb__, string playerId, int oldSkillID, int newSkillID, string data, Ice.Current current__);
+
+        void refreshPlayerAvatar_async(BattleIce.AMD_XmdsManager_refreshPlayerAvatar cb__, string playerId, string avatars, Ice.Current current__);
+
+        void getPlayerPKInfoData_async(BattleIce.AMD_XmdsManager_getPlayerPKInfoData cb__, string playerId, Ice.Current current__);
+
+        void getPlayerSkillCDTime_async(BattleIce.AMD_XmdsManager_getPlayerSkillCDTime cb__, string playerId, Ice.Current current__);
+
+        void canTalkWithNpc_async(BattleIce.AMD_XmdsManager_canTalkWithNpc cb__, string playerId, int npcId, Ice.Current current__);
+
+        void refreshPlayerPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPropertyChange cb__, string playerId, string data, Ice.Current current__);
+
+        void refreshPlayerPKMode_async(BattleIce.AMD_XmdsManager_refreshPlayerPKMode cb__, string playerId, bool isLook, int mode, Ice.Current current__);
+
+        void refreshPlayerPKValue_async(BattleIce.AMD_XmdsManager_refreshPlayerPKValue cb__, string playerId, int value, Ice.Current current__);
+
+        void refreshPlayerPKLevel_async(BattleIce.AMD_XmdsManager_refreshPlayerPKLevel cb__, string playerId, int level, Ice.Current current__);
+
+        void onFinishPickItem_async(BattleIce.AMD_XmdsManager_onFinishPickItem cb__, string playerId, string data, Ice.Current current__);
+
+        void refreshPlayerPetSkillChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetSkillChange cb__, string playerId, int operateID, string skills, Ice.Current current__);
+
+        void canUseItem_async(BattleIce.AMD_XmdsManager_canUseItem cb__, string playerId, Ice.Current current__);
+
+        void transferToPointPos_async(BattleIce.AMD_XmdsManager_transferToPointPos cb__, string instanceId, string playerId, string point, bool setDirection, float direction, Ice.Current current__);
+
+        void refreshPlayerPetPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetPropertyChange cb__, string playerId, string data, Ice.Current current__);
+
+        void getPlayerPetData_async(BattleIce.AMD_XmdsManager_getPlayerPetData cb__, string playerId, Ice.Current current__);
+
+        void triggrBattleFunction_async(BattleIce.AMD_XmdsManager_triggrBattleFunction cb__, string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, Ice.Current current__);
+
+        void addUnits_async(BattleIce.AMD_XmdsManager_addUnits cb__, string instanceId, string data, Ice.Current current__);
+
+        void refreshPlayerPetFollowModeChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__, string playerId, int mode, Ice.Current current__);
+
+        void playerReady_async(BattleIce.AMD_XmdsManager_playerReady cb__, string playerId, Ice.Current current__);
+
+        void refreshTeamData_async(BattleIce.AMD_XmdsManager_refreshTeamData cb__, string playerId, string data, Ice.Current current__);
+
+        void autoBattle_async(BattleIce.AMD_XmdsManager_autoBattle cb__, string instanceId, string playerId, bool enable, Ice.Current current__);
+
+        void getPlayerStatistic_async(BattleIce.AMD_XmdsManager_getPlayerStatistic cb__, string instanceId, string playerId, int flag, Ice.Current current__);
+
+        void getInstanceStatistic_async(BattleIce.AMD_XmdsManager_getInstanceStatistic cb__, string instanceId, Ice.Current current__);
+
+        void addUnit_async(BattleIce.AMD_XmdsManager_addUnit cb__, string instanceId, int unitTemplateID, string data, Ice.Current current__);
+
+        void removeUnit_async(BattleIce.AMD_XmdsManager_removeUnit cb__, string instanceId, int unitId, Ice.Current current__);
+
+        void removePointUnit_async(BattleIce.AMD_XmdsManager_removePointUnit cb__, string instanceId, int unitObjectId, Ice.Current current__);
+
+        void removeItem_async(BattleIce.AMD_XmdsManager_removeItem cb__, string instanceId, int itemId, Ice.Current current__);
+
+        void changePlayerState_async(BattleIce.AMD_XmdsManager_changePlayerState cb__, string instanceId, string playerId, byte status, int time, Ice.Current current__);
+
+        void playerChuanGong_async(BattleIce.AMD_XmdsManager_playerChuanGong cb__, string instanceId, string playerIdA, string playerIdB, Ice.Current current__);
+
+        void mountainKingRefreshNotify_async(BattleIce.AMD_XmdsManager_mountainKingRefreshNotify cb__, string instanceId, string data, Ice.Current current__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface XmdsManagerOperationsNC_
+    {
+        void notifyBattleServer_async(BattleIce.AMD_XmdsManager_notifyBattleServer cb__, string instanceId, string name, string data);
+
+        void getZoneStaticData_async(BattleIce.AMD_XmdsManager_getZoneStaticData cb__, string instanceId);
+
+        void getZoneRegions_async(BattleIce.AMD_XmdsManager_getZoneRegions cb__, string instanceId);
+
+        void getBornPlace_async(BattleIce.AMD_XmdsManager_getBornPlace cb__, string instanceId, int areaId, string pointId);
+
+        void getAllUnitInfo_async(BattleIce.AMD_XmdsManager_getAllUnitInfo cb__, string instanceId);
+
+        void getAllNpcInfo_async(BattleIce.AMD_XmdsManager_getAllNpcInfo cb__, string instanceId);
+
+        void getAllPlayerUUID_async(BattleIce.AMD_XmdsManager_getAllPlayerUUID cb__);
+
+        void getPlayerData_async(BattleIce.AMD_XmdsManager_getPlayerData cb__, string playerId, bool changeArea);
+
+        void onMonsterDiedDrops_async(BattleIce.AMD_XmdsManager_onMonsterDiedDrops cb__, string instanceId, string data);
+
+        void helpRevivePlayer_async(BattleIce.AMD_XmdsManager_helpRevivePlayer cb__, string playerId, string revivePlayerId, int time);
+
+        void revivePlayer_async(BattleIce.AMD_XmdsManager_revivePlayer cb__, string playerId, string data);
+
+        void refreshSummonMount_async(BattleIce.AMD_XmdsManager_refreshSummonMount cb__, string playerId, int time, int isUp);
+
+        void refreshPlayerBasicData_async(BattleIce.AMD_XmdsManager_refreshPlayerBasicData cb__, string playerId, string basic);
+
+        void refreshPlayerTeamData_async(BattleIce.AMD_XmdsManager_refreshPlayerTeamData cb__, string playerId, string uuidList);
+
+        void refreshPlayerRemainBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainBagCountData cb__, string playerId, int remainCount);
+
+        void refreshPlayerRemainTeamBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__, string playerId, int remainCount);
+
+        void refreshPlayerPetBaseInfoChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__, string playerId, string data);
+
+        void refreshPlayerPetDataChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetDataChange cb__, string playerId, int type, string data);
+
+        void refreshPlayerBattleEffect_async(BattleIce.AMD_XmdsManager_refreshPlayerBattleEffect cb__, string playerId, string effects);
+
+        void addPlayerAtt_async(BattleIce.AMD_XmdsManager_addPlayerAtt cb__, string playerId, string notifyPlayerIds, string key, int value);
+
+        void refreshPlayerSkill_async(BattleIce.AMD_XmdsManager_refreshPlayerSkill cb__, string playerId, int operateID, string skills);
+
+        void playerChangeSkill_async(BattleIce.AMD_XmdsManager_playerChangeSkill cb__, string playerId, int oldSkillID, int newSkillID, string data);
+
+        void refreshPlayerAvatar_async(BattleIce.AMD_XmdsManager_refreshPlayerAvatar cb__, string playerId, string avatars);
+
+        void getPlayerPKInfoData_async(BattleIce.AMD_XmdsManager_getPlayerPKInfoData cb__, string playerId);
+
+        void getPlayerSkillCDTime_async(BattleIce.AMD_XmdsManager_getPlayerSkillCDTime cb__, string playerId);
+
+        void canTalkWithNpc_async(BattleIce.AMD_XmdsManager_canTalkWithNpc cb__, string playerId, int npcId);
+
+        void refreshPlayerPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPropertyChange cb__, string playerId, string data);
+
+        void refreshPlayerPKMode_async(BattleIce.AMD_XmdsManager_refreshPlayerPKMode cb__, string playerId, bool isLook, int mode);
+
+        void refreshPlayerPKValue_async(BattleIce.AMD_XmdsManager_refreshPlayerPKValue cb__, string playerId, int value);
+
+        void refreshPlayerPKLevel_async(BattleIce.AMD_XmdsManager_refreshPlayerPKLevel cb__, string playerId, int level);
+
+        void onFinishPickItem_async(BattleIce.AMD_XmdsManager_onFinishPickItem cb__, string playerId, string data);
+
+        void refreshPlayerPetSkillChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetSkillChange cb__, string playerId, int operateID, string skills);
+
+        void canUseItem_async(BattleIce.AMD_XmdsManager_canUseItem cb__, string playerId);
+
+        void transferToPointPos_async(BattleIce.AMD_XmdsManager_transferToPointPos cb__, string instanceId, string playerId, string point, bool setDirection, float direction);
+
+        void refreshPlayerPetPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetPropertyChange cb__, string playerId, string data);
+
+        void getPlayerPetData_async(BattleIce.AMD_XmdsManager_getPlayerPetData cb__, string playerId);
+
+        void triggrBattleFunction_async(BattleIce.AMD_XmdsManager_triggrBattleFunction cb__, string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6);
+
+        void addUnits_async(BattleIce.AMD_XmdsManager_addUnits cb__, string instanceId, string data);
+
+        void refreshPlayerPetFollowModeChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__, string playerId, int mode);
+
+        void playerReady_async(BattleIce.AMD_XmdsManager_playerReady cb__, string playerId);
+
+        void refreshTeamData_async(BattleIce.AMD_XmdsManager_refreshTeamData cb__, string playerId, string data);
+
+        void autoBattle_async(BattleIce.AMD_XmdsManager_autoBattle cb__, string instanceId, string playerId, bool enable);
+
+        void getPlayerStatistic_async(BattleIce.AMD_XmdsManager_getPlayerStatistic cb__, string instanceId, string playerId, int flag);
+
+        void getInstanceStatistic_async(BattleIce.AMD_XmdsManager_getInstanceStatistic cb__, string instanceId);
+
+        void addUnit_async(BattleIce.AMD_XmdsManager_addUnit cb__, string instanceId, int unitTemplateID, string data);
+
+        void removeUnit_async(BattleIce.AMD_XmdsManager_removeUnit cb__, string instanceId, int unitId);
+
+        void removePointUnit_async(BattleIce.AMD_XmdsManager_removePointUnit cb__, string instanceId, int unitObjectId);
+
+        void removeItem_async(BattleIce.AMD_XmdsManager_removeItem cb__, string instanceId, int itemId);
+
+        void changePlayerState_async(BattleIce.AMD_XmdsManager_changePlayerState cb__, string instanceId, string playerId, byte status, int time);
+
+        void playerChuanGong_async(BattleIce.AMD_XmdsManager_playerChuanGong cb__, string instanceId, string playerIdA, string playerIdB);
+
+        void mountainKingRefreshNotify_async(BattleIce.AMD_XmdsManager_mountainKingRefreshNotify cb__, string instanceId, string data);
+    }
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class FinishPickItemPrxHelper : Ice.ObjectPrxHelperBase, FinishPickItemPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static FinishPickItemPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            FinishPickItemPrx r = b as FinishPickItemPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static FinishPickItemPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            FinishPickItemPrx r = b as FinishPickItemPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static FinishPickItemPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static FinishPickItemPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static FinishPickItemPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            FinishPickItemPrx r = b as FinishPickItemPrx;
+            if(r == null)
+            {
+                FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static FinishPickItemPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            FinishPickItemPrxHelper h = new FinishPickItemPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::FinishPickItem",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, FinishPickItemPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static FinishPickItemPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                FinishPickItemPrxHelper result = new FinishPickItemPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class PlayerPKInfoDataPrxHelper : Ice.ObjectPrxHelperBase, PlayerPKInfoDataPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static PlayerPKInfoDataPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            PlayerPKInfoDataPrx r = b as PlayerPKInfoDataPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static PlayerPKInfoDataPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            PlayerPKInfoDataPrx r = b as PlayerPKInfoDataPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static PlayerPKInfoDataPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static PlayerPKInfoDataPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static PlayerPKInfoDataPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            PlayerPKInfoDataPrx r = b as PlayerPKInfoDataPrx;
+            if(r == null)
+            {
+                PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static PlayerPKInfoDataPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            PlayerPKInfoDataPrxHelper h = new PlayerPKInfoDataPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::PlayerPKInfoData",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, PlayerPKInfoDataPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static PlayerPKInfoDataPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                PlayerPKInfoDataPrxHelper result = new PlayerPKInfoDataPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class CanTalkWithNpcPrxHelper : Ice.ObjectPrxHelperBase, CanTalkWithNpcPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static CanTalkWithNpcPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcPrx r = b as CanTalkWithNpcPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcPrx r = b as CanTalkWithNpcPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static CanTalkWithNpcPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static CanTalkWithNpcPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcPrx r = b as CanTalkWithNpcPrx;
+            if(r == null)
+            {
+                CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            CanTalkWithNpcPrxHelper h = new CanTalkWithNpcPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::CanTalkWithNpc",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, CanTalkWithNpcPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static CanTalkWithNpcPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                CanTalkWithNpcPrxHelper result = new CanTalkWithNpcPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class RefreshPlayerPropertyChangePrxHelper : Ice.ObjectPrxHelperBase, RefreshPlayerPropertyChangePrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static RefreshPlayerPropertyChangePrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            RefreshPlayerPropertyChangePrx r = b as RefreshPlayerPropertyChangePrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static RefreshPlayerPropertyChangePrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            RefreshPlayerPropertyChangePrx r = b as RefreshPlayerPropertyChangePrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static RefreshPlayerPropertyChangePrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static RefreshPlayerPropertyChangePrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static RefreshPlayerPropertyChangePrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            RefreshPlayerPropertyChangePrx r = b as RefreshPlayerPropertyChangePrx;
+            if(r == null)
+            {
+                RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static RefreshPlayerPropertyChangePrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            RefreshPlayerPropertyChangePrxHelper h = new RefreshPlayerPropertyChangePrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::RefreshPlayerPropertyChange",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, RefreshPlayerPropertyChangePrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static RefreshPlayerPropertyChangePrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                RefreshPlayerPropertyChangePrxHelper result = new RefreshPlayerPropertyChangePrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class SkillDataICEPrxHelper : Ice.ObjectPrxHelperBase, SkillDataICEPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static SkillDataICEPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            SkillDataICEPrx r = b as SkillDataICEPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static SkillDataICEPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            SkillDataICEPrx r = b as SkillDataICEPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static SkillDataICEPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static SkillDataICEPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static SkillDataICEPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            SkillDataICEPrx r = b as SkillDataICEPrx;
+            if(r == null)
+            {
+                SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static SkillDataICEPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            SkillDataICEPrxHelper h = new SkillDataICEPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::SkillDataICE",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, SkillDataICEPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static SkillDataICEPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                SkillDataICEPrxHelper result = new SkillDataICEPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class SkillDataSeqHelper
+    {
+        public static void write(IceInternal.BasicStream os__, BattleIce.SkillDataICE[] v__)
+        {
+            if(v__ == null)
+            {
+                os__.writeSize(0);
+            }
+            else
+            {
+                os__.writeSize(v__.Length);
+                for(int ix__ = 0; ix__ < v__.Length; ++ix__)
+                {
+                    os__.writeObject(v__[ix__]);
+                }
+            }
+        }
+
+        public static BattleIce.SkillDataICE[] read(IceInternal.BasicStream is__)
+        {
+            BattleIce.SkillDataICE[] v__;
+            {
+                int szx__ = is__.readAndCheckSeqSize(1);
+                v__ = new BattleIce.SkillDataICE[szx__];
+                for(int ix__ = 0; ix__ < szx__; ++ix__)
+                {
+                    IceInternal.ArrayPatcher<BattleIce.SkillDataICE> spx = new IceInternal.ArrayPatcher<BattleIce.SkillDataICE>("::BattleIce::SkillDataICE", v__, ix__);
+                    is__.readObject(spx);
+                }
+            }
+            return v__;
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class GetPlayerDataPrxHelper : Ice.ObjectPrxHelperBase, GetPlayerDataPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static GetPlayerDataPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            GetPlayerDataPrx r = b as GetPlayerDataPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static GetPlayerDataPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            GetPlayerDataPrx r = b as GetPlayerDataPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static GetPlayerDataPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static GetPlayerDataPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static GetPlayerDataPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            GetPlayerDataPrx r = b as GetPlayerDataPrx;
+            if(r == null)
+            {
+                GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static GetPlayerDataPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            GetPlayerDataPrxHelper h = new GetPlayerDataPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::GetPlayerData",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, GetPlayerDataPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static GetPlayerDataPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                GetPlayerDataPrxHelper result = new GetPlayerDataPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class CanTalkWithNpcResultPrxHelper : Ice.ObjectPrxHelperBase, CanTalkWithNpcResultPrx
+    {
+        #region Asynchronous operations
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static CanTalkWithNpcResultPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcResultPrx r = b as CanTalkWithNpcResultPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcResultPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcResultPrx r = b as CanTalkWithNpcResultPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcResultPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static CanTalkWithNpcResultPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static CanTalkWithNpcResultPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            CanTalkWithNpcResultPrx r = b as CanTalkWithNpcResultPrx;
+            if(r == null)
+            {
+                CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static CanTalkWithNpcResultPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            CanTalkWithNpcResultPrxHelper h = new CanTalkWithNpcResultPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::CanTalkWithNpcResult",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, CanTalkWithNpcResultPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static CanTalkWithNpcResultPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                CanTalkWithNpcResultPrxHelper result = new CanTalkWithNpcResultPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class XmdsManagerPrxHelper : Ice.ObjectPrxHelperBase, XmdsManagerPrx
+    {
+        #region Synchronous operations
+
+        public void addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value)
+        {
+            this.addPlayerAtt(playerId, notifyPlayerIds, key, value, null, false);
+        }
+
+        public void addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.addPlayerAtt(playerId, notifyPlayerIds, key, value, ctx__, true);
+        }
+
+        private void addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_addPlayerAtt(begin_addPlayerAtt(playerId, notifyPlayerIds, key, value, context__, explicitCtx__, true, null, null));
+        }
+
+        public int addUnit(string instanceId, int unitTemplateID, string data)
+        {
+            return this.addUnit(instanceId, unitTemplateID, data, null, false);
+        }
+
+        public int addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.addUnit(instanceId, unitTemplateID, data, ctx__, true);
+        }
+
+        private int addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__addUnit_name);
+            return end_addUnit(begin_addUnit(instanceId, unitTemplateID, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public int addUnits(string instanceId, string data)
+        {
+            return this.addUnits(instanceId, data, null, false);
+        }
+
+        public int addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.addUnits(instanceId, data, ctx__, true);
+        }
+
+        private int addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__addUnits_name);
+            return end_addUnits(begin_addUnits(instanceId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void autoBattle(string instanceId, string playerId, bool enable)
+        {
+            this.autoBattle(instanceId, playerId, enable, null, false);
+        }
+
+        public void autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.autoBattle(instanceId, playerId, enable, ctx__, true);
+        }
+
+        private void autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_autoBattle(begin_autoBattle(instanceId, playerId, enable, context__, explicitCtx__, true, null, null));
+        }
+
+        public string canTalkWithNpc(string playerId, int npcId)
+        {
+            return this.canTalkWithNpc(playerId, npcId, null, false);
+        }
+
+        public string canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.canTalkWithNpc(playerId, npcId, ctx__, true);
+        }
+
+        private string canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__canTalkWithNpc_name);
+            return end_canTalkWithNpc(begin_canTalkWithNpc(playerId, npcId, context__, explicitCtx__, true, null, null));
+        }
+
+        public bool canUseItem(string playerId)
+        {
+            return this.canUseItem(playerId, null, false);
+        }
+
+        public bool canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.canUseItem(playerId, ctx__, true);
+        }
+
+        private bool canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__canUseItem_name);
+            return end_canUseItem(begin_canUseItem(playerId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void changePlayerState(string instanceId, string playerId, byte status, int time)
+        {
+            this.changePlayerState(instanceId, playerId, status, time, null, false);
+        }
+
+        public void changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.changePlayerState(instanceId, playerId, status, time, ctx__, true);
+        }
+
+        private void changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_changePlayerState(begin_changePlayerState(instanceId, playerId, status, time, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getAllNpcInfo(string instanceId)
+        {
+            return this.getAllNpcInfo(instanceId, null, false);
+        }
+
+        public string getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getAllNpcInfo(instanceId, ctx__, true);
+        }
+
+        private string getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getAllNpcInfo_name);
+            return end_getAllNpcInfo(begin_getAllNpcInfo(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getAllPlayerUUID()
+        {
+            return this.getAllPlayerUUID(null, false);
+        }
+
+        public string getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getAllPlayerUUID(ctx__, true);
+        }
+
+        private string getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getAllPlayerUUID_name);
+            return end_getAllPlayerUUID(begin_getAllPlayerUUID(context__, explicitCtx__, true, null, null));
+        }
+
+        public string getAllUnitInfo(string instanceId)
+        {
+            return this.getAllUnitInfo(instanceId, null, false);
+        }
+
+        public string getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getAllUnitInfo(instanceId, ctx__, true);
+        }
+
+        private string getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getAllUnitInfo_name);
+            return end_getAllUnitInfo(begin_getAllUnitInfo(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getBornPlace(string instanceId, int areaId, string pointId)
+        {
+            return this.getBornPlace(instanceId, areaId, pointId, null, false);
+        }
+
+        public string getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getBornPlace(instanceId, areaId, pointId, ctx__, true);
+        }
+
+        private string getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getBornPlace_name);
+            return end_getBornPlace(begin_getBornPlace(instanceId, areaId, pointId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getInstanceStatistic(string instanceId)
+        {
+            return this.getInstanceStatistic(instanceId, null, false);
+        }
+
+        public string getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getInstanceStatistic(instanceId, ctx__, true);
+        }
+
+        private string getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getInstanceStatistic_name);
+            return end_getInstanceStatistic(begin_getInstanceStatistic(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getPlayerData(string playerId, bool changeArea)
+        {
+            return this.getPlayerData(playerId, changeArea, null, false);
+        }
+
+        public string getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getPlayerData(playerId, changeArea, ctx__, true);
+        }
+
+        private string getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getPlayerData_name);
+            return end_getPlayerData(begin_getPlayerData(playerId, changeArea, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getPlayerPKInfoData(string playerId)
+        {
+            return this.getPlayerPKInfoData(playerId, null, false);
+        }
+
+        public string getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getPlayerPKInfoData(playerId, ctx__, true);
+        }
+
+        private string getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getPlayerPKInfoData_name);
+            return end_getPlayerPKInfoData(begin_getPlayerPKInfoData(playerId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getPlayerPetData(string playerId)
+        {
+            return this.getPlayerPetData(playerId, null, false);
+        }
+
+        public string getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getPlayerPetData(playerId, ctx__, true);
+        }
+
+        private string getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getPlayerPetData_name);
+            return end_getPlayerPetData(begin_getPlayerPetData(playerId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getPlayerSkillCDTime(string playerId)
+        {
+            return this.getPlayerSkillCDTime(playerId, null, false);
+        }
+
+        public string getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getPlayerSkillCDTime(playerId, ctx__, true);
+        }
+
+        private string getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getPlayerSkillCDTime_name);
+            return end_getPlayerSkillCDTime(begin_getPlayerSkillCDTime(playerId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getPlayerStatistic(string instanceId, string playerId, int flag)
+        {
+            return this.getPlayerStatistic(instanceId, playerId, flag, null, false);
+        }
+
+        public string getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getPlayerStatistic(instanceId, playerId, flag, ctx__, true);
+        }
+
+        private string getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getPlayerStatistic_name);
+            return end_getPlayerStatistic(begin_getPlayerStatistic(instanceId, playerId, flag, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getZoneRegions(string instanceId)
+        {
+            return this.getZoneRegions(instanceId, null, false);
+        }
+
+        public string getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getZoneRegions(instanceId, ctx__, true);
+        }
+
+        private string getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getZoneRegions_name);
+            return end_getZoneRegions(begin_getZoneRegions(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public string getZoneStaticData(string instanceId)
+        {
+            return this.getZoneStaticData(instanceId, null, false);
+        }
+
+        public string getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getZoneStaticData(instanceId, ctx__, true);
+        }
+
+        private string getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getZoneStaticData_name);
+            return end_getZoneStaticData(begin_getZoneStaticData(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void helpRevivePlayer(string playerId, string revivePlayerId, int time)
+        {
+            this.helpRevivePlayer(playerId, revivePlayerId, time, null, false);
+        }
+
+        public void helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.helpRevivePlayer(playerId, revivePlayerId, time, ctx__, true);
+        }
+
+        private void helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_helpRevivePlayer(begin_helpRevivePlayer(playerId, revivePlayerId, time, context__, explicitCtx__, true, null, null));
+        }
+
+        public void mountainKingRefreshNotify(string instanceId, string data)
+        {
+            this.mountainKingRefreshNotify(instanceId, data, null, false);
+        }
+
+        public void mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.mountainKingRefreshNotify(instanceId, data, ctx__, true);
+        }
+
+        private void mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_mountainKingRefreshNotify(begin_mountainKingRefreshNotify(instanceId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void notifyBattleServer(string instanceId, string name, string data)
+        {
+            this.notifyBattleServer(instanceId, name, data, null, false);
+        }
+
+        public void notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.notifyBattleServer(instanceId, name, data, ctx__, true);
+        }
+
+        private void notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_notifyBattleServer(begin_notifyBattleServer(instanceId, name, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void onFinishPickItem(string playerId, string data)
+        {
+            this.onFinishPickItem(playerId, data, null, false);
+        }
+
+        public void onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.onFinishPickItem(playerId, data, ctx__, true);
+        }
+
+        private void onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_onFinishPickItem(begin_onFinishPickItem(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void onMonsterDiedDrops(string instanceId, string data)
+        {
+            this.onMonsterDiedDrops(instanceId, data, null, false);
+        }
+
+        public void onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.onMonsterDiedDrops(instanceId, data, ctx__, true);
+        }
+
+        private void onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_onMonsterDiedDrops(begin_onMonsterDiedDrops(instanceId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data)
+        {
+            this.playerChangeSkill(playerId, oldSkillID, newSkillID, data, null, false);
+        }
+
+        public void playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerChangeSkill(playerId, oldSkillID, newSkillID, data, ctx__, true);
+        }
+
+        private void playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerChangeSkill(begin_playerChangeSkill(playerId, oldSkillID, newSkillID, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerChuanGong(string instanceId, string playerIdA, string playerIdB)
+        {
+            this.playerChuanGong(instanceId, playerIdA, playerIdB, null, false);
+        }
+
+        public void playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerChuanGong(instanceId, playerIdA, playerIdB, ctx__, true);
+        }
+
+        private void playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerChuanGong(begin_playerChuanGong(instanceId, playerIdA, playerIdB, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerReady(string playerId)
+        {
+            this.playerReady(playerId, null, false);
+        }
+
+        public void playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerReady(playerId, ctx__, true);
+        }
+
+        private void playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerReady(begin_playerReady(playerId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerAvatar(string playerId, string avatars)
+        {
+            this.refreshPlayerAvatar(playerId, avatars, null, false);
+        }
+
+        public void refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerAvatar(playerId, avatars, ctx__, true);
+        }
+
+        private void refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerAvatar(begin_refreshPlayerAvatar(playerId, avatars, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerBasicData(string playerId, string basic)
+        {
+            this.refreshPlayerBasicData(playerId, basic, null, false);
+        }
+
+        public void refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerBasicData(playerId, basic, ctx__, true);
+        }
+
+        private void refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerBasicData(begin_refreshPlayerBasicData(playerId, basic, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerBattleEffect(string playerId, string effects)
+        {
+            this.refreshPlayerBattleEffect(playerId, effects, null, false);
+        }
+
+        public void refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerBattleEffect(playerId, effects, ctx__, true);
+        }
+
+        private void refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerBattleEffect(begin_refreshPlayerBattleEffect(playerId, effects, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPKLevel(string playerId, int level)
+        {
+            this.refreshPlayerPKLevel(playerId, level, null, false);
+        }
+
+        public void refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPKLevel(playerId, level, ctx__, true);
+        }
+
+        private void refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPKLevel(begin_refreshPlayerPKLevel(playerId, level, context__, explicitCtx__, true, null, null));
+        }
+
+        public int refreshPlayerPKMode(string playerId, bool isLook, int mode)
+        {
+            return this.refreshPlayerPKMode(playerId, isLook, mode, null, false);
+        }
+
+        public int refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.refreshPlayerPKMode(playerId, isLook, mode, ctx__, true);
+        }
+
+        private int refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__refreshPlayerPKMode_name);
+            return end_refreshPlayerPKMode(begin_refreshPlayerPKMode(playerId, isLook, mode, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPKValue(string playerId, int value)
+        {
+            this.refreshPlayerPKValue(playerId, value, null, false);
+        }
+
+        public void refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPKValue(playerId, value, ctx__, true);
+        }
+
+        private void refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPKValue(begin_refreshPlayerPKValue(playerId, value, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPetBaseInfoChange(string playerId, string data)
+        {
+            this.refreshPlayerPetBaseInfoChange(playerId, data, null, false);
+        }
+
+        public void refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPetBaseInfoChange(playerId, data, ctx__, true);
+        }
+
+        private void refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPetBaseInfoChange(begin_refreshPlayerPetBaseInfoChange(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public int refreshPlayerPetDataChange(string playerId, int type, string data)
+        {
+            return this.refreshPlayerPetDataChange(playerId, type, data, null, false);
+        }
+
+        public int refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.refreshPlayerPetDataChange(playerId, type, data, ctx__, true);
+        }
+
+        private int refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__refreshPlayerPetDataChange_name);
+            return end_refreshPlayerPetDataChange(begin_refreshPlayerPetDataChange(playerId, type, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPetFollowModeChange(string playerId, int mode)
+        {
+            this.refreshPlayerPetFollowModeChange(playerId, mode, null, false);
+        }
+
+        public void refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPetFollowModeChange(playerId, mode, ctx__, true);
+        }
+
+        private void refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPetFollowModeChange(begin_refreshPlayerPetFollowModeChange(playerId, mode, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPetPropertyChange(string playerId, string data)
+        {
+            this.refreshPlayerPetPropertyChange(playerId, data, null, false);
+        }
+
+        public void refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPetPropertyChange(playerId, data, ctx__, true);
+        }
+
+        private void refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPetPropertyChange(begin_refreshPlayerPetPropertyChange(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPetSkillChange(string playerId, int operateID, string skills)
+        {
+            this.refreshPlayerPetSkillChange(playerId, operateID, skills, null, false);
+        }
+
+        public void refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPetSkillChange(playerId, operateID, skills, ctx__, true);
+        }
+
+        private void refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPetSkillChange(begin_refreshPlayerPetSkillChange(playerId, operateID, skills, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerPropertyChange(string playerId, string data)
+        {
+            this.refreshPlayerPropertyChange(playerId, data, null, false);
+        }
+
+        public void refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerPropertyChange(playerId, data, ctx__, true);
+        }
+
+        private void refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerPropertyChange(begin_refreshPlayerPropertyChange(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerRemainBagCountData(string playerId, int remainCount)
+        {
+            this.refreshPlayerRemainBagCountData(playerId, remainCount, null, false);
+        }
+
+        public void refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerRemainBagCountData(playerId, remainCount, ctx__, true);
+        }
+
+        private void refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerRemainBagCountData(begin_refreshPlayerRemainBagCountData(playerId, remainCount, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerRemainTeamBagCountData(string playerId, int remainCount)
+        {
+            this.refreshPlayerRemainTeamBagCountData(playerId, remainCount, null, false);
+        }
+
+        public void refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerRemainTeamBagCountData(playerId, remainCount, ctx__, true);
+        }
+
+        private void refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerRemainTeamBagCountData(begin_refreshPlayerRemainTeamBagCountData(playerId, remainCount, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerSkill(string playerId, int operateID, string skills)
+        {
+            this.refreshPlayerSkill(playerId, operateID, skills, null, false);
+        }
+
+        public void refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerSkill(playerId, operateID, skills, ctx__, true);
+        }
+
+        private void refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerSkill(begin_refreshPlayerSkill(playerId, operateID, skills, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshPlayerTeamData(string playerId, string uuidList)
+        {
+            this.refreshPlayerTeamData(playerId, uuidList, null, false);
+        }
+
+        public void refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshPlayerTeamData(playerId, uuidList, ctx__, true);
+        }
+
+        private void refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshPlayerTeamData(begin_refreshPlayerTeamData(playerId, uuidList, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshSummonMount(string playerId, int time, int isUp)
+        {
+            this.refreshSummonMount(playerId, time, isUp, null, false);
+        }
+
+        public void refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshSummonMount(playerId, time, isUp, ctx__, true);
+        }
+
+        private void refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshSummonMount(begin_refreshSummonMount(playerId, time, isUp, context__, explicitCtx__, true, null, null));
+        }
+
+        public void refreshTeamData(string playerId, string data)
+        {
+            this.refreshTeamData(playerId, data, null, false);
+        }
+
+        public void refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.refreshTeamData(playerId, data, ctx__, true);
+        }
+
+        private void refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_refreshTeamData(begin_refreshTeamData(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void removeItem(string instanceId, int itemId)
+        {
+            this.removeItem(instanceId, itemId, null, false);
+        }
+
+        public void removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.removeItem(instanceId, itemId, ctx__, true);
+        }
+
+        private void removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_removeItem(begin_removeItem(instanceId, itemId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void removePointUnit(string instanceId, int unitObjectId)
+        {
+            this.removePointUnit(instanceId, unitObjectId, null, false);
+        }
+
+        public void removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.removePointUnit(instanceId, unitObjectId, ctx__, true);
+        }
+
+        private void removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_removePointUnit(begin_removePointUnit(instanceId, unitObjectId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void removeUnit(string instanceId, int unitId)
+        {
+            this.removeUnit(instanceId, unitId, null, false);
+        }
+
+        public void removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.removeUnit(instanceId, unitId, ctx__, true);
+        }
+
+        private void removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_removeUnit(begin_removeUnit(instanceId, unitId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void revivePlayer(string playerId, string data)
+        {
+            this.revivePlayer(playerId, data, null, false);
+        }
+
+        public void revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.revivePlayer(playerId, data, ctx__, true);
+        }
+
+        private void revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_revivePlayer(begin_revivePlayer(playerId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public bool transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction)
+        {
+            return this.transferToPointPos(instanceId, playerId, point, setDirection, direction, null, false);
+        }
+
+        public bool transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.transferToPointPos(instanceId, playerId, point, setDirection, direction, ctx__, true);
+        }
+
+        private bool transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__transferToPointPos_name);
+            return end_transferToPointPos(begin_transferToPointPos(instanceId, playerId, point, setDirection, direction, context__, explicitCtx__, true, null, null));
+        }
+
+        public void triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6)
+        {
+            this.triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, null, false);
+        }
+
+        public void triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, ctx__, true);
+        }
+
+        private void triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_triggrBattleFunction(begin_triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, context__, explicitCtx__, true, null, null));
+        }
+
+        #endregion
+
+        #region Asynchronous operations
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addPlayerAtt> begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value)
+        {
+            return begin_addPlayerAtt(playerId, notifyPlayerIds, key, value, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addPlayerAtt> begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_addPlayerAtt(playerId, notifyPlayerIds, key, value, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addPlayerAtt(playerId, notifyPlayerIds, key, value, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addPlayerAtt(playerId, notifyPlayerIds, key, value, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __addPlayerAtt_name = "addPlayerAtt";
+
+        public void end_addPlayerAtt(Ice.AsyncResult r__)
+        {
+            end__(r__, __addPlayerAtt_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_addPlayerAtt> begin_addPlayerAtt(string playerId, string notifyPlayerIds, string key, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_addPlayerAtt> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_addPlayerAtt>(__addPlayerAtt_name, addPlayerAtt_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__addPlayerAtt_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(notifyPlayerIds);
+                os__.writeString(key);
+                os__.writeInt(value);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void addPlayerAtt_completed__(BattleIce.Callback_XmdsManager_addPlayerAtt cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnit> begin_addUnit(string instanceId, int unitTemplateID, string data)
+        {
+            return begin_addUnit(instanceId, unitTemplateID, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnit> begin_addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_addUnit(instanceId, unitTemplateID, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_addUnit(string instanceId, int unitTemplateID, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addUnit(instanceId, unitTemplateID, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addUnit(instanceId, unitTemplateID, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __addUnit_name = "addUnit";
+
+        public int end_addUnit(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __addUnit_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnit> begin_addUnit(string instanceId, int unitTemplateID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__addUnit_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_addUnit> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_addUnit>(__addUnit_name, addUnit_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__addUnit_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(unitTemplateID);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void addUnit_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_addUnit cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_addUnit(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnits> begin_addUnits(string instanceId, string data)
+        {
+            return begin_addUnits(instanceId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnits> begin_addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_addUnits(instanceId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_addUnits(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addUnits(instanceId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_addUnits(instanceId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __addUnits_name = "addUnits";
+
+        public int end_addUnits(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __addUnits_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_addUnits> begin_addUnits(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__addUnits_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_addUnits> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_addUnits>(__addUnits_name, addUnits_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__addUnits_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void addUnits_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_addUnits cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_addUnits(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_autoBattle> begin_autoBattle(string instanceId, string playerId, bool enable)
+        {
+            return begin_autoBattle(instanceId, playerId, enable, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_autoBattle> begin_autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_autoBattle(instanceId, playerId, enable, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_autoBattle(string instanceId, string playerId, bool enable, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_autoBattle(instanceId, playerId, enable, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_autoBattle(instanceId, playerId, enable, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __autoBattle_name = "autoBattle";
+
+        public void end_autoBattle(Ice.AsyncResult r__)
+        {
+            end__(r__, __autoBattle_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_autoBattle> begin_autoBattle(string instanceId, string playerId, bool enable, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_autoBattle> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_autoBattle>(__autoBattle_name, autoBattle_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__autoBattle_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(playerId);
+                os__.writeBool(enable);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void autoBattle_completed__(BattleIce.Callback_XmdsManager_autoBattle cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_canTalkWithNpc> begin_canTalkWithNpc(string playerId, int npcId)
+        {
+            return begin_canTalkWithNpc(playerId, npcId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_canTalkWithNpc> begin_canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_canTalkWithNpc(playerId, npcId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_canTalkWithNpc(string playerId, int npcId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_canTalkWithNpc(playerId, npcId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_canTalkWithNpc(playerId, npcId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __canTalkWithNpc_name = "canTalkWithNpc";
+
+        public string end_canTalkWithNpc(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __canTalkWithNpc_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_canTalkWithNpc> begin_canTalkWithNpc(string playerId, int npcId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__canTalkWithNpc_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_canTalkWithNpc> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_canTalkWithNpc>(__canTalkWithNpc_name, canTalkWithNpc_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__canTalkWithNpc_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(npcId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void canTalkWithNpc_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_canTalkWithNpc cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_canTalkWithNpc(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_canUseItem> begin_canUseItem(string playerId)
+        {
+            return begin_canUseItem(playerId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_canUseItem> begin_canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_canUseItem(playerId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_canUseItem(string playerId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_canUseItem(playerId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_canUseItem(playerId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __canUseItem_name = "canUseItem";
+
+        public bool end_canUseItem(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __canUseItem_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                bool ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readBool();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_canUseItem> begin_canUseItem(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__canUseItem_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_canUseItem> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_canUseItem>(__canUseItem_name, canUseItem_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__canUseItem_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void canUseItem_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_canUseItem cb__, Ice.ExceptionCallback excb__)
+        {
+            bool ret__;
+            try
+            {
+                ret__ = end_canUseItem(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_changePlayerState> begin_changePlayerState(string instanceId, string playerId, byte status, int time)
+        {
+            return begin_changePlayerState(instanceId, playerId, status, time, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_changePlayerState> begin_changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_changePlayerState(instanceId, playerId, status, time, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_changePlayerState(string instanceId, string playerId, byte status, int time, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_changePlayerState(instanceId, playerId, status, time, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_changePlayerState(instanceId, playerId, status, time, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __changePlayerState_name = "changePlayerState";
+
+        public void end_changePlayerState(Ice.AsyncResult r__)
+        {
+            end__(r__, __changePlayerState_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_changePlayerState> begin_changePlayerState(string instanceId, string playerId, byte status, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_changePlayerState> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_changePlayerState>(__changePlayerState_name, changePlayerState_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__changePlayerState_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(playerId);
+                os__.writeByte(status);
+                os__.writeInt(time);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void changePlayerState_completed__(BattleIce.Callback_XmdsManager_changePlayerState cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllNpcInfo> begin_getAllNpcInfo(string instanceId)
+        {
+            return begin_getAllNpcInfo(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllNpcInfo> begin_getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getAllNpcInfo(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getAllNpcInfo(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllNpcInfo(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllNpcInfo(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getAllNpcInfo_name = "getAllNpcInfo";
+
+        public string end_getAllNpcInfo(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getAllNpcInfo_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllNpcInfo> begin_getAllNpcInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getAllNpcInfo_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllNpcInfo> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllNpcInfo>(__getAllNpcInfo_name, getAllNpcInfo_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getAllNpcInfo_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getAllNpcInfo_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getAllNpcInfo cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getAllNpcInfo(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllPlayerUUID> begin_getAllPlayerUUID()
+        {
+            return begin_getAllPlayerUUID(null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllPlayerUUID> begin_getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getAllPlayerUUID(ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getAllPlayerUUID(Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllPlayerUUID(null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllPlayerUUID(ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getAllPlayerUUID_name = "getAllPlayerUUID";
+
+        public string end_getAllPlayerUUID(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getAllPlayerUUID_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllPlayerUUID> begin_getAllPlayerUUID(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getAllPlayerUUID_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllPlayerUUID> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllPlayerUUID>(__getAllPlayerUUID_name, getAllPlayerUUID_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getAllPlayerUUID_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                result__.writeEmptyParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getAllPlayerUUID_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getAllPlayerUUID cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getAllPlayerUUID(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllUnitInfo> begin_getAllUnitInfo(string instanceId)
+        {
+            return begin_getAllUnitInfo(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllUnitInfo> begin_getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getAllUnitInfo(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getAllUnitInfo(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllUnitInfo(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllUnitInfo(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getAllUnitInfo_name = "getAllUnitInfo";
+
+        public string end_getAllUnitInfo(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getAllUnitInfo_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getAllUnitInfo> begin_getAllUnitInfo(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getAllUnitInfo_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllUnitInfo> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getAllUnitInfo>(__getAllUnitInfo_name, getAllUnitInfo_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getAllUnitInfo_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getAllUnitInfo_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getAllUnitInfo cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getAllUnitInfo(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getBornPlace> begin_getBornPlace(string instanceId, int areaId, string pointId)
+        {
+            return begin_getBornPlace(instanceId, areaId, pointId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getBornPlace> begin_getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getBornPlace(instanceId, areaId, pointId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getBornPlace(string instanceId, int areaId, string pointId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getBornPlace(instanceId, areaId, pointId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getBornPlace(instanceId, areaId, pointId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getBornPlace_name = "getBornPlace";
+
+        public string end_getBornPlace(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getBornPlace_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getBornPlace> begin_getBornPlace(string instanceId, int areaId, string pointId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getBornPlace_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getBornPlace> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getBornPlace>(__getBornPlace_name, getBornPlace_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getBornPlace_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(areaId);
+                os__.writeString(pointId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getBornPlace_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getBornPlace cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getBornPlace(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getInstanceStatistic> begin_getInstanceStatistic(string instanceId)
+        {
+            return begin_getInstanceStatistic(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getInstanceStatistic> begin_getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getInstanceStatistic(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getInstanceStatistic(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getInstanceStatistic(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getInstanceStatistic(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getInstanceStatistic_name = "getInstanceStatistic";
+
+        public string end_getInstanceStatistic(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getInstanceStatistic_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getInstanceStatistic> begin_getInstanceStatistic(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getInstanceStatistic_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getInstanceStatistic> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getInstanceStatistic>(__getInstanceStatistic_name, getInstanceStatistic_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getInstanceStatistic_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getInstanceStatistic_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getInstanceStatistic cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getInstanceStatistic(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerData> begin_getPlayerData(string playerId, bool changeArea)
+        {
+            return begin_getPlayerData(playerId, changeArea, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerData> begin_getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getPlayerData(playerId, changeArea, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getPlayerData(string playerId, bool changeArea, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerData(playerId, changeArea, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerData(playerId, changeArea, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getPlayerData_name = "getPlayerData";
+
+        public string end_getPlayerData(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getPlayerData_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerData> begin_getPlayerData(string playerId, bool changeArea, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getPlayerData_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerData> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerData>(__getPlayerData_name, getPlayerData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getPlayerData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeBool(changeArea);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getPlayerData_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getPlayerData cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getPlayerData(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> begin_getPlayerPKInfoData(string playerId)
+        {
+            return begin_getPlayerPKInfoData(playerId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> begin_getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getPlayerPKInfoData(playerId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getPlayerPKInfoData(string playerId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerPKInfoData(playerId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerPKInfoData(playerId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getPlayerPKInfoData_name = "getPlayerPKInfoData";
+
+        public string end_getPlayerPKInfoData(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getPlayerPKInfoData_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> begin_getPlayerPKInfoData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getPlayerPKInfoData_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerPKInfoData> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerPKInfoData>(__getPlayerPKInfoData_name, getPlayerPKInfoData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getPlayerPKInfoData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getPlayerPKInfoData_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getPlayerPKInfoData cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getPlayerPKInfoData(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPetData> begin_getPlayerPetData(string playerId)
+        {
+            return begin_getPlayerPetData(playerId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPetData> begin_getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getPlayerPetData(playerId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getPlayerPetData(string playerId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerPetData(playerId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerPetData(playerId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getPlayerPetData_name = "getPlayerPetData";
+
+        public string end_getPlayerPetData(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getPlayerPetData_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerPetData> begin_getPlayerPetData(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getPlayerPetData_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerPetData> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerPetData>(__getPlayerPetData_name, getPlayerPetData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getPlayerPetData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getPlayerPetData_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getPlayerPetData cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getPlayerPetData(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> begin_getPlayerSkillCDTime(string playerId)
+        {
+            return begin_getPlayerSkillCDTime(playerId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> begin_getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getPlayerSkillCDTime(playerId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getPlayerSkillCDTime(string playerId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerSkillCDTime(playerId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerSkillCDTime(playerId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getPlayerSkillCDTime_name = "getPlayerSkillCDTime";
+
+        public string end_getPlayerSkillCDTime(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getPlayerSkillCDTime_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> begin_getPlayerSkillCDTime(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getPlayerSkillCDTime_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerSkillCDTime>(__getPlayerSkillCDTime_name, getPlayerSkillCDTime_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getPlayerSkillCDTime_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getPlayerSkillCDTime_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getPlayerSkillCDTime cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getPlayerSkillCDTime(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerStatistic> begin_getPlayerStatistic(string instanceId, string playerId, int flag)
+        {
+            return begin_getPlayerStatistic(instanceId, playerId, flag, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerStatistic> begin_getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getPlayerStatistic(instanceId, playerId, flag, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getPlayerStatistic(string instanceId, string playerId, int flag, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerStatistic(instanceId, playerId, flag, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getPlayerStatistic(instanceId, playerId, flag, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getPlayerStatistic_name = "getPlayerStatistic";
+
+        public string end_getPlayerStatistic(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getPlayerStatistic_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getPlayerStatistic> begin_getPlayerStatistic(string instanceId, string playerId, int flag, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getPlayerStatistic_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerStatistic> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getPlayerStatistic>(__getPlayerStatistic_name, getPlayerStatistic_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getPlayerStatistic_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(playerId);
+                os__.writeInt(flag);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getPlayerStatistic_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getPlayerStatistic cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getPlayerStatistic(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneRegions> begin_getZoneRegions(string instanceId)
+        {
+            return begin_getZoneRegions(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneRegions> begin_getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getZoneRegions(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getZoneRegions(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getZoneRegions(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getZoneRegions(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getZoneRegions_name = "getZoneRegions";
+
+        public string end_getZoneRegions(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getZoneRegions_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneRegions> begin_getZoneRegions(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getZoneRegions_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getZoneRegions> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getZoneRegions>(__getZoneRegions_name, getZoneRegions_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getZoneRegions_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getZoneRegions_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getZoneRegions cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getZoneRegions(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneStaticData> begin_getZoneStaticData(string instanceId)
+        {
+            return begin_getZoneStaticData(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneStaticData> begin_getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getZoneStaticData(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getZoneStaticData(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getZoneStaticData(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getZoneStaticData(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getZoneStaticData_name = "getZoneStaticData";
+
+        public string end_getZoneStaticData(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getZoneStaticData_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_getZoneStaticData> begin_getZoneStaticData(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getZoneStaticData_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getZoneStaticData> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_getZoneStaticData>(__getZoneStaticData_name, getZoneStaticData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getZoneStaticData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getZoneStaticData_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_getZoneStaticData cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getZoneStaticData(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_helpRevivePlayer> begin_helpRevivePlayer(string playerId, string revivePlayerId, int time)
+        {
+            return begin_helpRevivePlayer(playerId, revivePlayerId, time, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_helpRevivePlayer> begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_helpRevivePlayer(playerId, revivePlayerId, time, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_helpRevivePlayer(playerId, revivePlayerId, time, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_helpRevivePlayer(playerId, revivePlayerId, time, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __helpRevivePlayer_name = "helpRevivePlayer";
+
+        public void end_helpRevivePlayer(Ice.AsyncResult r__)
+        {
+            end__(r__, __helpRevivePlayer_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_helpRevivePlayer> begin_helpRevivePlayer(string playerId, string revivePlayerId, int time, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_helpRevivePlayer> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_helpRevivePlayer>(__helpRevivePlayer_name, helpRevivePlayer_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__helpRevivePlayer_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(revivePlayerId);
+                os__.writeInt(time);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void helpRevivePlayer_completed__(BattleIce.Callback_XmdsManager_helpRevivePlayer cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> begin_mountainKingRefreshNotify(string instanceId, string data)
+        {
+            return begin_mountainKingRefreshNotify(instanceId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> begin_mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_mountainKingRefreshNotify(instanceId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_mountainKingRefreshNotify(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_mountainKingRefreshNotify(instanceId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_mountainKingRefreshNotify(instanceId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __mountainKingRefreshNotify_name = "mountainKingRefreshNotify";
+
+        public void end_mountainKingRefreshNotify(Ice.AsyncResult r__)
+        {
+            end__(r__, __mountainKingRefreshNotify_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> begin_mountainKingRefreshNotify(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_mountainKingRefreshNotify>(__mountainKingRefreshNotify_name, mountainKingRefreshNotify_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__mountainKingRefreshNotify_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void mountainKingRefreshNotify_completed__(BattleIce.Callback_XmdsManager_mountainKingRefreshNotify cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_notifyBattleServer> begin_notifyBattleServer(string instanceId, string name, string data)
+        {
+            return begin_notifyBattleServer(instanceId, name, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_notifyBattleServer> begin_notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_notifyBattleServer(instanceId, name, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_notifyBattleServer(string instanceId, string name, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_notifyBattleServer(instanceId, name, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_notifyBattleServer(instanceId, name, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __notifyBattleServer_name = "notifyBattleServer";
+
+        public void end_notifyBattleServer(Ice.AsyncResult r__)
+        {
+            end__(r__, __notifyBattleServer_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_notifyBattleServer> begin_notifyBattleServer(string instanceId, string name, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_notifyBattleServer> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_notifyBattleServer>(__notifyBattleServer_name, notifyBattleServer_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__notifyBattleServer_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(name);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void notifyBattleServer_completed__(BattleIce.Callback_XmdsManager_notifyBattleServer cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_onFinishPickItem> begin_onFinishPickItem(string playerId, string data)
+        {
+            return begin_onFinishPickItem(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_onFinishPickItem> begin_onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_onFinishPickItem(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_onFinishPickItem(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_onFinishPickItem(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_onFinishPickItem(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __onFinishPickItem_name = "onFinishPickItem";
+
+        public void end_onFinishPickItem(Ice.AsyncResult r__)
+        {
+            end__(r__, __onFinishPickItem_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_onFinishPickItem> begin_onFinishPickItem(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_onFinishPickItem> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_onFinishPickItem>(__onFinishPickItem_name, onFinishPickItem_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__onFinishPickItem_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void onFinishPickItem_completed__(BattleIce.Callback_XmdsManager_onFinishPickItem cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> begin_onMonsterDiedDrops(string instanceId, string data)
+        {
+            return begin_onMonsterDiedDrops(instanceId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> begin_onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_onMonsterDiedDrops(instanceId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_onMonsterDiedDrops(string instanceId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_onMonsterDiedDrops(instanceId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_onMonsterDiedDrops(instanceId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __onMonsterDiedDrops_name = "onMonsterDiedDrops";
+
+        public void end_onMonsterDiedDrops(Ice.AsyncResult r__)
+        {
+            end__(r__, __onMonsterDiedDrops_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> begin_onMonsterDiedDrops(string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_onMonsterDiedDrops> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_onMonsterDiedDrops>(__onMonsterDiedDrops_name, onMonsterDiedDrops_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__onMonsterDiedDrops_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void onMonsterDiedDrops_completed__(BattleIce.Callback_XmdsManager_onMonsterDiedDrops cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChangeSkill> begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data)
+        {
+            return begin_playerChangeSkill(playerId, oldSkillID, newSkillID, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChangeSkill> begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerChangeSkill(playerId, oldSkillID, newSkillID, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerChangeSkill(playerId, oldSkillID, newSkillID, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerChangeSkill(playerId, oldSkillID, newSkillID, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerChangeSkill_name = "playerChangeSkill";
+
+        public void end_playerChangeSkill(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerChangeSkill_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChangeSkill> begin_playerChangeSkill(string playerId, int oldSkillID, int newSkillID, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerChangeSkill> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerChangeSkill>(__playerChangeSkill_name, playerChangeSkill_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerChangeSkill_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(oldSkillID);
+                os__.writeInt(newSkillID);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerChangeSkill_completed__(BattleIce.Callback_XmdsManager_playerChangeSkill cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChuanGong> begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB)
+        {
+            return begin_playerChuanGong(instanceId, playerIdA, playerIdB, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChuanGong> begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerChuanGong(instanceId, playerIdA, playerIdB, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerChuanGong(instanceId, playerIdA, playerIdB, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerChuanGong(instanceId, playerIdA, playerIdB, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerChuanGong_name = "playerChuanGong";
+
+        public void end_playerChuanGong(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerChuanGong_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerChuanGong> begin_playerChuanGong(string instanceId, string playerIdA, string playerIdB, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerChuanGong> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerChuanGong>(__playerChuanGong_name, playerChuanGong_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerChuanGong_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(playerIdA);
+                os__.writeString(playerIdB);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerChuanGong_completed__(BattleIce.Callback_XmdsManager_playerChuanGong cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerReady> begin_playerReady(string playerId)
+        {
+            return begin_playerReady(playerId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerReady> begin_playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerReady(playerId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerReady(string playerId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerReady(playerId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerReady(playerId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerReady_name = "playerReady";
+
+        public void end_playerReady(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerReady_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_playerReady> begin_playerReady(string playerId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerReady> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_playerReady>(__playerReady_name, playerReady_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerReady_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerReady_completed__(BattleIce.Callback_XmdsManager_playerReady cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> begin_refreshPlayerAvatar(string playerId, string avatars)
+        {
+            return begin_refreshPlayerAvatar(playerId, avatars, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> begin_refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerAvatar(playerId, avatars, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerAvatar(string playerId, string avatars, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerAvatar(playerId, avatars, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerAvatar(playerId, avatars, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerAvatar_name = "refreshPlayerAvatar";
+
+        public void end_refreshPlayerAvatar(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerAvatar_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> begin_refreshPlayerAvatar(string playerId, string avatars, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerAvatar> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerAvatar>(__refreshPlayerAvatar_name, refreshPlayerAvatar_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerAvatar_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(avatars);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerAvatar_completed__(BattleIce.Callback_XmdsManager_refreshPlayerAvatar cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> begin_refreshPlayerBasicData(string playerId, string basic)
+        {
+            return begin_refreshPlayerBasicData(playerId, basic, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> begin_refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerBasicData(playerId, basic, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerBasicData(string playerId, string basic, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerBasicData(playerId, basic, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerBasicData(playerId, basic, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerBasicData_name = "refreshPlayerBasicData";
+
+        public void end_refreshPlayerBasicData(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerBasicData_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> begin_refreshPlayerBasicData(string playerId, string basic, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerBasicData> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerBasicData>(__refreshPlayerBasicData_name, refreshPlayerBasicData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerBasicData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(basic);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerBasicData_completed__(BattleIce.Callback_XmdsManager_refreshPlayerBasicData cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> begin_refreshPlayerBattleEffect(string playerId, string effects)
+        {
+            return begin_refreshPlayerBattleEffect(playerId, effects, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> begin_refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerBattleEffect(playerId, effects, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerBattleEffect(string playerId, string effects, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerBattleEffect(playerId, effects, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerBattleEffect(playerId, effects, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerBattleEffect_name = "refreshPlayerBattleEffect";
+
+        public void end_refreshPlayerBattleEffect(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerBattleEffect_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> begin_refreshPlayerBattleEffect(string playerId, string effects, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect>(__refreshPlayerBattleEffect_name, refreshPlayerBattleEffect_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerBattleEffect_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(effects);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerBattleEffect_completed__(BattleIce.Callback_XmdsManager_refreshPlayerBattleEffect cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> begin_refreshPlayerPKLevel(string playerId, int level)
+        {
+            return begin_refreshPlayerPKLevel(playerId, level, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> begin_refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPKLevel(playerId, level, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKLevel(string playerId, int level, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKLevel(playerId, level, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKLevel(playerId, level, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPKLevel_name = "refreshPlayerPKLevel";
+
+        public void end_refreshPlayerPKLevel(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPKLevel_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> begin_refreshPlayerPKLevel(string playerId, int level, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKLevel>(__refreshPlayerPKLevel_name, refreshPlayerPKLevel_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPKLevel_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(level);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPKLevel_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPKLevel cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> begin_refreshPlayerPKMode(string playerId, bool isLook, int mode)
+        {
+            return begin_refreshPlayerPKMode(playerId, isLook, mode, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPKMode(playerId, isLook, mode, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKMode(playerId, isLook, mode, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKMode(playerId, isLook, mode, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPKMode_name = "refreshPlayerPKMode";
+
+        public int end_refreshPlayerPKMode(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __refreshPlayerPKMode_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> begin_refreshPlayerPKMode(string playerId, bool isLook, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__refreshPlayerPKMode_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKMode> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKMode>(__refreshPlayerPKMode_name, refreshPlayerPKMode_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPKMode_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeBool(isLook);
+                os__.writeInt(mode);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPKMode_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_refreshPlayerPKMode cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_refreshPlayerPKMode(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> begin_refreshPlayerPKValue(string playerId, int value)
+        {
+            return begin_refreshPlayerPKValue(playerId, value, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> begin_refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPKValue(playerId, value, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKValue(string playerId, int value, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKValue(playerId, value, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPKValue(playerId, value, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPKValue_name = "refreshPlayerPKValue";
+
+        public void end_refreshPlayerPKValue(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPKValue_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> begin_refreshPlayerPKValue(string playerId, int value, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKValue> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPKValue>(__refreshPlayerPKValue_name, refreshPlayerPKValue_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPKValue_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(value);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPKValue_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPKValue cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> begin_refreshPlayerPetBaseInfoChange(string playerId, string data)
+        {
+            return begin_refreshPlayerPetBaseInfoChange(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> begin_refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPetBaseInfoChange(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetBaseInfoChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetBaseInfoChange(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetBaseInfoChange(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPetBaseInfoChange_name = "refreshPlayerPetBaseInfoChange";
+
+        public void end_refreshPlayerPetBaseInfoChange(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPetBaseInfoChange_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> begin_refreshPlayerPetBaseInfoChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange>(__refreshPlayerPetBaseInfoChange_name, refreshPlayerPetBaseInfoChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPetBaseInfoChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPetBaseInfoChange_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPetBaseInfoChange cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> begin_refreshPlayerPetDataChange(string playerId, int type, string data)
+        {
+            return begin_refreshPlayerPetDataChange(playerId, type, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> begin_refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPetDataChange(playerId, type, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetDataChange(string playerId, int type, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetDataChange(playerId, type, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetDataChange(playerId, type, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPetDataChange_name = "refreshPlayerPetDataChange";
+
+        public int end_refreshPlayerPetDataChange(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __refreshPlayerPetDataChange_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> begin_refreshPlayerPetDataChange(string playerId, int type, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__refreshPlayerPetDataChange_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange>(__refreshPlayerPetDataChange_name, refreshPlayerPetDataChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPetDataChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(type);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPetDataChange_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_refreshPlayerPetDataChange cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_refreshPlayerPetDataChange(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> begin_refreshPlayerPetFollowModeChange(string playerId, int mode)
+        {
+            return begin_refreshPlayerPetFollowModeChange(playerId, mode, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> begin_refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPetFollowModeChange(playerId, mode, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetFollowModeChange(string playerId, int mode, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetFollowModeChange(playerId, mode, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetFollowModeChange(playerId, mode, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPetFollowModeChange_name = "refreshPlayerPetFollowModeChange";
+
+        public void end_refreshPlayerPetFollowModeChange(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPetFollowModeChange_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> begin_refreshPlayerPetFollowModeChange(string playerId, int mode, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange>(__refreshPlayerPetFollowModeChange_name, refreshPlayerPetFollowModeChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPetFollowModeChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(mode);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPetFollowModeChange_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPetFollowModeChange cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> begin_refreshPlayerPetPropertyChange(string playerId, string data)
+        {
+            return begin_refreshPlayerPetPropertyChange(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> begin_refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPetPropertyChange(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetPropertyChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetPropertyChange(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetPropertyChange(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPetPropertyChange_name = "refreshPlayerPetPropertyChange";
+
+        public void end_refreshPlayerPetPropertyChange(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPetPropertyChange_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> begin_refreshPlayerPetPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange>(__refreshPlayerPetPropertyChange_name, refreshPlayerPetPropertyChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPetPropertyChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPetPropertyChange_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPetPropertyChange cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills)
+        {
+            return begin_refreshPlayerPetSkillChange(playerId, operateID, skills, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPetSkillChange(playerId, operateID, skills, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetSkillChange(playerId, operateID, skills, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPetSkillChange(playerId, operateID, skills, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPetSkillChange_name = "refreshPlayerPetSkillChange";
+
+        public void end_refreshPlayerPetSkillChange(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPetSkillChange_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> begin_refreshPlayerPetSkillChange(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange>(__refreshPlayerPetSkillChange_name, refreshPlayerPetSkillChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPetSkillChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(operateID);
+                os__.writeString(skills);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPetSkillChange_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPetSkillChange cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> begin_refreshPlayerPropertyChange(string playerId, string data)
+        {
+            return begin_refreshPlayerPropertyChange(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> begin_refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerPropertyChange(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPropertyChange(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPropertyChange(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerPropertyChange(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerPropertyChange_name = "refreshPlayerPropertyChange";
+
+        public void end_refreshPlayerPropertyChange(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerPropertyChange_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> begin_refreshPlayerPropertyChange(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange>(__refreshPlayerPropertyChange_name, refreshPlayerPropertyChange_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerPropertyChange_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerPropertyChange_completed__(BattleIce.Callback_XmdsManager_refreshPlayerPropertyChange cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> begin_refreshPlayerRemainBagCountData(string playerId, int remainCount)
+        {
+            return begin_refreshPlayerRemainBagCountData(playerId, remainCount, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerRemainBagCountData(playerId, remainCount, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerRemainBagCountData(playerId, remainCount, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerRemainBagCountData(playerId, remainCount, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerRemainBagCountData_name = "refreshPlayerRemainBagCountData";
+
+        public void end_refreshPlayerRemainBagCountData(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerRemainBagCountData_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> begin_refreshPlayerRemainBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData>(__refreshPlayerRemainBagCountData_name, refreshPlayerRemainBagCountData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerRemainBagCountData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(remainCount);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerRemainBagCountData_completed__(BattleIce.Callback_XmdsManager_refreshPlayerRemainBagCountData cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount)
+        {
+            return begin_refreshPlayerRemainTeamBagCountData(playerId, remainCount, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerRemainTeamBagCountData(playerId, remainCount, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerRemainTeamBagCountData(playerId, remainCount, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerRemainTeamBagCountData(playerId, remainCount, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerRemainTeamBagCountData_name = "refreshPlayerRemainTeamBagCountData";
+
+        public void end_refreshPlayerRemainTeamBagCountData(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerRemainTeamBagCountData_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> begin_refreshPlayerRemainTeamBagCountData(string playerId, int remainCount, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData>(__refreshPlayerRemainTeamBagCountData_name, refreshPlayerRemainTeamBagCountData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerRemainTeamBagCountData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(remainCount);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerRemainTeamBagCountData_completed__(BattleIce.Callback_XmdsManager_refreshPlayerRemainTeamBagCountData cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerSkill> begin_refreshPlayerSkill(string playerId, int operateID, string skills)
+        {
+            return begin_refreshPlayerSkill(playerId, operateID, skills, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerSkill> begin_refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerSkill(playerId, operateID, skills, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerSkill(string playerId, int operateID, string skills, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerSkill(playerId, operateID, skills, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerSkill(playerId, operateID, skills, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerSkill_name = "refreshPlayerSkill";
+
+        public void end_refreshPlayerSkill(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerSkill_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerSkill> begin_refreshPlayerSkill(string playerId, int operateID, string skills, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerSkill> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerSkill>(__refreshPlayerSkill_name, refreshPlayerSkill_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerSkill_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(operateID);
+                os__.writeString(skills);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerSkill_completed__(BattleIce.Callback_XmdsManager_refreshPlayerSkill cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> begin_refreshPlayerTeamData(string playerId, string uuidList)
+        {
+            return begin_refreshPlayerTeamData(playerId, uuidList, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> begin_refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshPlayerTeamData(playerId, uuidList, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerTeamData(string playerId, string uuidList, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerTeamData(playerId, uuidList, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshPlayerTeamData(playerId, uuidList, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshPlayerTeamData_name = "refreshPlayerTeamData";
+
+        public void end_refreshPlayerTeamData(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshPlayerTeamData_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> begin_refreshPlayerTeamData(string playerId, string uuidList, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerTeamData> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshPlayerTeamData>(__refreshPlayerTeamData_name, refreshPlayerTeamData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshPlayerTeamData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(uuidList);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshPlayerTeamData_completed__(BattleIce.Callback_XmdsManager_refreshPlayerTeamData cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshSummonMount> begin_refreshSummonMount(string playerId, int time, int isUp)
+        {
+            return begin_refreshSummonMount(playerId, time, isUp, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshSummonMount> begin_refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshSummonMount(playerId, time, isUp, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshSummonMount(string playerId, int time, int isUp, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshSummonMount(playerId, time, isUp, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshSummonMount(playerId, time, isUp, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshSummonMount_name = "refreshSummonMount";
+
+        public void end_refreshSummonMount(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshSummonMount_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshSummonMount> begin_refreshSummonMount(string playerId, int time, int isUp, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshSummonMount> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshSummonMount>(__refreshSummonMount_name, refreshSummonMount_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshSummonMount_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(time);
+                os__.writeInt(isUp);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshSummonMount_completed__(BattleIce.Callback_XmdsManager_refreshSummonMount cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshTeamData> begin_refreshTeamData(string playerId, string data)
+        {
+            return begin_refreshTeamData(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshTeamData> begin_refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_refreshTeamData(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_refreshTeamData(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshTeamData(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_refreshTeamData(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __refreshTeamData_name = "refreshTeamData";
+
+        public void end_refreshTeamData(Ice.AsyncResult r__)
+        {
+            end__(r__, __refreshTeamData_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_refreshTeamData> begin_refreshTeamData(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshTeamData> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_refreshTeamData>(__refreshTeamData_name, refreshTeamData_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__refreshTeamData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void refreshTeamData_completed__(BattleIce.Callback_XmdsManager_refreshTeamData cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeItem> begin_removeItem(string instanceId, int itemId)
+        {
+            return begin_removeItem(instanceId, itemId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeItem> begin_removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_removeItem(instanceId, itemId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_removeItem(string instanceId, int itemId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removeItem(instanceId, itemId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removeItem(instanceId, itemId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __removeItem_name = "removeItem";
+
+        public void end_removeItem(Ice.AsyncResult r__)
+        {
+            end__(r__, __removeItem_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeItem> begin_removeItem(string instanceId, int itemId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removeItem> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removeItem>(__removeItem_name, removeItem_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__removeItem_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(itemId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void removeItem_completed__(BattleIce.Callback_XmdsManager_removeItem cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removePointUnit> begin_removePointUnit(string instanceId, int unitObjectId)
+        {
+            return begin_removePointUnit(instanceId, unitObjectId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removePointUnit> begin_removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_removePointUnit(instanceId, unitObjectId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_removePointUnit(string instanceId, int unitObjectId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removePointUnit(instanceId, unitObjectId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removePointUnit(instanceId, unitObjectId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __removePointUnit_name = "removePointUnit";
+
+        public void end_removePointUnit(Ice.AsyncResult r__)
+        {
+            end__(r__, __removePointUnit_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_removePointUnit> begin_removePointUnit(string instanceId, int unitObjectId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removePointUnit> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removePointUnit>(__removePointUnit_name, removePointUnit_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__removePointUnit_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(unitObjectId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void removePointUnit_completed__(BattleIce.Callback_XmdsManager_removePointUnit cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeUnit> begin_removeUnit(string instanceId, int unitId)
+        {
+            return begin_removeUnit(instanceId, unitId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeUnit> begin_removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_removeUnit(instanceId, unitId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_removeUnit(string instanceId, int unitId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removeUnit(instanceId, unitId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_removeUnit(instanceId, unitId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __removeUnit_name = "removeUnit";
+
+        public void end_removeUnit(Ice.AsyncResult r__)
+        {
+            end__(r__, __removeUnit_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_removeUnit> begin_removeUnit(string instanceId, int unitId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removeUnit> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_removeUnit>(__removeUnit_name, removeUnit_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__removeUnit_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(unitId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void removeUnit_completed__(BattleIce.Callback_XmdsManager_removeUnit cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_revivePlayer> begin_revivePlayer(string playerId, string data)
+        {
+            return begin_revivePlayer(playerId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_revivePlayer> begin_revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_revivePlayer(playerId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_revivePlayer(string playerId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_revivePlayer(playerId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_revivePlayer(playerId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __revivePlayer_name = "revivePlayer";
+
+        public void end_revivePlayer(Ice.AsyncResult r__)
+        {
+            end__(r__, __revivePlayer_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_revivePlayer> begin_revivePlayer(string playerId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_revivePlayer> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_revivePlayer>(__revivePlayer_name, revivePlayer_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__revivePlayer_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void revivePlayer_completed__(BattleIce.Callback_XmdsManager_revivePlayer cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_transferToPointPos> begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction)
+        {
+            return begin_transferToPointPos(instanceId, playerId, point, setDirection, direction, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_transferToPointPos> begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_transferToPointPos(instanceId, playerId, point, setDirection, direction, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_transferToPointPos(instanceId, playerId, point, setDirection, direction, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_transferToPointPos(instanceId, playerId, point, setDirection, direction, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __transferToPointPos_name = "transferToPointPos";
+
+        public bool end_transferToPointPos(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __transferToPointPos_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                bool ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readBool();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_transferToPointPos> begin_transferToPointPos(string instanceId, string playerId, string point, bool setDirection, float direction, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__transferToPointPos_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_XmdsManager_transferToPointPos> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_XmdsManager_transferToPointPos>(__transferToPointPos_name, transferToPointPos_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__transferToPointPos_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeString(playerId);
+                os__.writeString(point);
+                os__.writeBool(setDirection);
+                os__.writeFloat(direction);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void transferToPointPos_completed__(Ice.AsyncResult r__, BattleIce.Callback_XmdsManager_transferToPointPos cb__, Ice.ExceptionCallback excb__)
+        {
+            bool ret__;
+            try
+            {
+                ret__ = end_transferToPointPos(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_triggrBattleFunction> begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6)
+        {
+            return begin_triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_XmdsManager_triggrBattleFunction> begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_triggrBattleFunction(playerId, eventId, value1, valu2, valu3, valu4, value5, value6, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __triggrBattleFunction_name = "triggrBattleFunction";
+
+        public void end_triggrBattleFunction(Ice.AsyncResult r__)
+        {
+            end__(r__, __triggrBattleFunction_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_XmdsManager_triggrBattleFunction> begin_triggrBattleFunction(string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_XmdsManager_triggrBattleFunction> result__ = getOnewayOutgoingAsync<BattleIce.Callback_XmdsManager_triggrBattleFunction>(__triggrBattleFunction_name, triggrBattleFunction_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__triggrBattleFunction_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeInt(eventId);
+                os__.writeInt(value1);
+                os__.writeInt(valu2);
+                os__.writeInt(valu3);
+                os__.writeInt(valu4);
+                os__.writeInt(value5);
+                os__.writeInt(value6);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void triggrBattleFunction_completed__(BattleIce.Callback_XmdsManager_triggrBattleFunction cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static XmdsManagerPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            XmdsManagerPrx r = b as XmdsManagerPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static XmdsManagerPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            XmdsManagerPrx r = b as XmdsManagerPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static XmdsManagerPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static XmdsManagerPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static XmdsManagerPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            XmdsManagerPrx r = b as XmdsManagerPrx;
+            if(r == null)
+            {
+                XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static XmdsManagerPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            XmdsManagerPrxHelper h = new XmdsManagerPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::XmdsManager",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, XmdsManagerPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static XmdsManagerPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                XmdsManagerPrxHelper result = new XmdsManagerPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public abstract class XmdsManagerDisp_ : Ice.ObjectImpl, XmdsManager
+    {
+        #region Slice operations
+
+        public void notifyBattleServer_async(BattleIce.AMD_XmdsManager_notifyBattleServer cb__, string instanceId, string name, string data)
+        {
+            notifyBattleServer_async(cb__, instanceId, name, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void notifyBattleServer_async(BattleIce.AMD_XmdsManager_notifyBattleServer cb__, string instanceId, string name, string data, Ice.Current current__);
+
+        public void getZoneStaticData_async(BattleIce.AMD_XmdsManager_getZoneStaticData cb__, string instanceId)
+        {
+            getZoneStaticData_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getZoneStaticData_async(BattleIce.AMD_XmdsManager_getZoneStaticData cb__, string instanceId, Ice.Current current__);
+
+        public void getZoneRegions_async(BattleIce.AMD_XmdsManager_getZoneRegions cb__, string instanceId)
+        {
+            getZoneRegions_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getZoneRegions_async(BattleIce.AMD_XmdsManager_getZoneRegions cb__, string instanceId, Ice.Current current__);
+
+        public void getBornPlace_async(BattleIce.AMD_XmdsManager_getBornPlace cb__, string instanceId, int areaId, string pointId)
+        {
+            getBornPlace_async(cb__, instanceId, areaId, pointId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getBornPlace_async(BattleIce.AMD_XmdsManager_getBornPlace cb__, string instanceId, int areaId, string pointId, Ice.Current current__);
+
+        public void getAllUnitInfo_async(BattleIce.AMD_XmdsManager_getAllUnitInfo cb__, string instanceId)
+        {
+            getAllUnitInfo_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getAllUnitInfo_async(BattleIce.AMD_XmdsManager_getAllUnitInfo cb__, string instanceId, Ice.Current current__);
+
+        public void getAllNpcInfo_async(BattleIce.AMD_XmdsManager_getAllNpcInfo cb__, string instanceId)
+        {
+            getAllNpcInfo_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getAllNpcInfo_async(BattleIce.AMD_XmdsManager_getAllNpcInfo cb__, string instanceId, Ice.Current current__);
+
+        public void getAllPlayerUUID_async(BattleIce.AMD_XmdsManager_getAllPlayerUUID cb__)
+        {
+            getAllPlayerUUID_async(cb__, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getAllPlayerUUID_async(BattleIce.AMD_XmdsManager_getAllPlayerUUID cb__, Ice.Current current__);
+
+        public void getPlayerData_async(BattleIce.AMD_XmdsManager_getPlayerData cb__, string playerId, bool changeArea)
+        {
+            getPlayerData_async(cb__, playerId, changeArea, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getPlayerData_async(BattleIce.AMD_XmdsManager_getPlayerData cb__, string playerId, bool changeArea, Ice.Current current__);
+
+        public void onMonsterDiedDrops_async(BattleIce.AMD_XmdsManager_onMonsterDiedDrops cb__, string instanceId, string data)
+        {
+            onMonsterDiedDrops_async(cb__, instanceId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void onMonsterDiedDrops_async(BattleIce.AMD_XmdsManager_onMonsterDiedDrops cb__, string instanceId, string data, Ice.Current current__);
+
+        public void helpRevivePlayer_async(BattleIce.AMD_XmdsManager_helpRevivePlayer cb__, string playerId, string revivePlayerId, int time)
+        {
+            helpRevivePlayer_async(cb__, playerId, revivePlayerId, time, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void helpRevivePlayer_async(BattleIce.AMD_XmdsManager_helpRevivePlayer cb__, string playerId, string revivePlayerId, int time, Ice.Current current__);
+
+        public void revivePlayer_async(BattleIce.AMD_XmdsManager_revivePlayer cb__, string playerId, string data)
+        {
+            revivePlayer_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void revivePlayer_async(BattleIce.AMD_XmdsManager_revivePlayer cb__, string playerId, string data, Ice.Current current__);
+
+        public void refreshSummonMount_async(BattleIce.AMD_XmdsManager_refreshSummonMount cb__, string playerId, int time, int isUp)
+        {
+            refreshSummonMount_async(cb__, playerId, time, isUp, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshSummonMount_async(BattleIce.AMD_XmdsManager_refreshSummonMount cb__, string playerId, int time, int isUp, Ice.Current current__);
+
+        public void refreshPlayerBasicData_async(BattleIce.AMD_XmdsManager_refreshPlayerBasicData cb__, string playerId, string basic)
+        {
+            refreshPlayerBasicData_async(cb__, playerId, basic, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerBasicData_async(BattleIce.AMD_XmdsManager_refreshPlayerBasicData cb__, string playerId, string basic, Ice.Current current__);
+
+        public void refreshPlayerTeamData_async(BattleIce.AMD_XmdsManager_refreshPlayerTeamData cb__, string playerId, string uuidList)
+        {
+            refreshPlayerTeamData_async(cb__, playerId, uuidList, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerTeamData_async(BattleIce.AMD_XmdsManager_refreshPlayerTeamData cb__, string playerId, string uuidList, Ice.Current current__);
+
+        public void refreshPlayerRemainBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainBagCountData cb__, string playerId, int remainCount)
+        {
+            refreshPlayerRemainBagCountData_async(cb__, playerId, remainCount, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerRemainBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainBagCountData cb__, string playerId, int remainCount, Ice.Current current__);
+
+        public void refreshPlayerRemainTeamBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__, string playerId, int remainCount)
+        {
+            refreshPlayerRemainTeamBagCountData_async(cb__, playerId, remainCount, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerRemainTeamBagCountData_async(BattleIce.AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__, string playerId, int remainCount, Ice.Current current__);
+
+        public void refreshPlayerPetBaseInfoChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__, string playerId, string data)
+        {
+            refreshPlayerPetBaseInfoChange_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPetBaseInfoChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__, string playerId, string data, Ice.Current current__);
+
+        public void refreshPlayerPetDataChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetDataChange cb__, string playerId, int type, string data)
+        {
+            refreshPlayerPetDataChange_async(cb__, playerId, type, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPetDataChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetDataChange cb__, string playerId, int type, string data, Ice.Current current__);
+
+        public void refreshPlayerBattleEffect_async(BattleIce.AMD_XmdsManager_refreshPlayerBattleEffect cb__, string playerId, string effects)
+        {
+            refreshPlayerBattleEffect_async(cb__, playerId, effects, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerBattleEffect_async(BattleIce.AMD_XmdsManager_refreshPlayerBattleEffect cb__, string playerId, string effects, Ice.Current current__);
+
+        public void addPlayerAtt_async(BattleIce.AMD_XmdsManager_addPlayerAtt cb__, string playerId, string notifyPlayerIds, string key, int value)
+        {
+            addPlayerAtt_async(cb__, playerId, notifyPlayerIds, key, value, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void addPlayerAtt_async(BattleIce.AMD_XmdsManager_addPlayerAtt cb__, string playerId, string notifyPlayerIds, string key, int value, Ice.Current current__);
+
+        public void refreshPlayerSkill_async(BattleIce.AMD_XmdsManager_refreshPlayerSkill cb__, string playerId, int operateID, string skills)
+        {
+            refreshPlayerSkill_async(cb__, playerId, operateID, skills, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerSkill_async(BattleIce.AMD_XmdsManager_refreshPlayerSkill cb__, string playerId, int operateID, string skills, Ice.Current current__);
+
+        public void playerChangeSkill_async(BattleIce.AMD_XmdsManager_playerChangeSkill cb__, string playerId, int oldSkillID, int newSkillID, string data)
+        {
+            playerChangeSkill_async(cb__, playerId, oldSkillID, newSkillID, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerChangeSkill_async(BattleIce.AMD_XmdsManager_playerChangeSkill cb__, string playerId, int oldSkillID, int newSkillID, string data, Ice.Current current__);
+
+        public void refreshPlayerAvatar_async(BattleIce.AMD_XmdsManager_refreshPlayerAvatar cb__, string playerId, string avatars)
+        {
+            refreshPlayerAvatar_async(cb__, playerId, avatars, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerAvatar_async(BattleIce.AMD_XmdsManager_refreshPlayerAvatar cb__, string playerId, string avatars, Ice.Current current__);
+
+        public void getPlayerPKInfoData_async(BattleIce.AMD_XmdsManager_getPlayerPKInfoData cb__, string playerId)
+        {
+            getPlayerPKInfoData_async(cb__, playerId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getPlayerPKInfoData_async(BattleIce.AMD_XmdsManager_getPlayerPKInfoData cb__, string playerId, Ice.Current current__);
+
+        public void getPlayerSkillCDTime_async(BattleIce.AMD_XmdsManager_getPlayerSkillCDTime cb__, string playerId)
+        {
+            getPlayerSkillCDTime_async(cb__, playerId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getPlayerSkillCDTime_async(BattleIce.AMD_XmdsManager_getPlayerSkillCDTime cb__, string playerId, Ice.Current current__);
+
+        public void canTalkWithNpc_async(BattleIce.AMD_XmdsManager_canTalkWithNpc cb__, string playerId, int npcId)
+        {
+            canTalkWithNpc_async(cb__, playerId, npcId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void canTalkWithNpc_async(BattleIce.AMD_XmdsManager_canTalkWithNpc cb__, string playerId, int npcId, Ice.Current current__);
+
+        public void refreshPlayerPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPropertyChange cb__, string playerId, string data)
+        {
+            refreshPlayerPropertyChange_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPropertyChange cb__, string playerId, string data, Ice.Current current__);
+
+        public void refreshPlayerPKMode_async(BattleIce.AMD_XmdsManager_refreshPlayerPKMode cb__, string playerId, bool isLook, int mode)
+        {
+            refreshPlayerPKMode_async(cb__, playerId, isLook, mode, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPKMode_async(BattleIce.AMD_XmdsManager_refreshPlayerPKMode cb__, string playerId, bool isLook, int mode, Ice.Current current__);
+
+        public void refreshPlayerPKValue_async(BattleIce.AMD_XmdsManager_refreshPlayerPKValue cb__, string playerId, int value)
+        {
+            refreshPlayerPKValue_async(cb__, playerId, value, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPKValue_async(BattleIce.AMD_XmdsManager_refreshPlayerPKValue cb__, string playerId, int value, Ice.Current current__);
+
+        public void refreshPlayerPKLevel_async(BattleIce.AMD_XmdsManager_refreshPlayerPKLevel cb__, string playerId, int level)
+        {
+            refreshPlayerPKLevel_async(cb__, playerId, level, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPKLevel_async(BattleIce.AMD_XmdsManager_refreshPlayerPKLevel cb__, string playerId, int level, Ice.Current current__);
+
+        public void onFinishPickItem_async(BattleIce.AMD_XmdsManager_onFinishPickItem cb__, string playerId, string data)
+        {
+            onFinishPickItem_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void onFinishPickItem_async(BattleIce.AMD_XmdsManager_onFinishPickItem cb__, string playerId, string data, Ice.Current current__);
+
+        public void refreshPlayerPetSkillChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetSkillChange cb__, string playerId, int operateID, string skills)
+        {
+            refreshPlayerPetSkillChange_async(cb__, playerId, operateID, skills, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPetSkillChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetSkillChange cb__, string playerId, int operateID, string skills, Ice.Current current__);
+
+        public void canUseItem_async(BattleIce.AMD_XmdsManager_canUseItem cb__, string playerId)
+        {
+            canUseItem_async(cb__, playerId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void canUseItem_async(BattleIce.AMD_XmdsManager_canUseItem cb__, string playerId, Ice.Current current__);
+
+        public void transferToPointPos_async(BattleIce.AMD_XmdsManager_transferToPointPos cb__, string instanceId, string playerId, string point, bool setDirection, float direction)
+        {
+            transferToPointPos_async(cb__, instanceId, playerId, point, setDirection, direction, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void transferToPointPos_async(BattleIce.AMD_XmdsManager_transferToPointPos cb__, string instanceId, string playerId, string point, bool setDirection, float direction, Ice.Current current__);
+
+        public void refreshPlayerPetPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetPropertyChange cb__, string playerId, string data)
+        {
+            refreshPlayerPetPropertyChange_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPetPropertyChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetPropertyChange cb__, string playerId, string data, Ice.Current current__);
+
+        public void getPlayerPetData_async(BattleIce.AMD_XmdsManager_getPlayerPetData cb__, string playerId)
+        {
+            getPlayerPetData_async(cb__, playerId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getPlayerPetData_async(BattleIce.AMD_XmdsManager_getPlayerPetData cb__, string playerId, Ice.Current current__);
+
+        public void triggrBattleFunction_async(BattleIce.AMD_XmdsManager_triggrBattleFunction cb__, string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6)
+        {
+            triggrBattleFunction_async(cb__, playerId, eventId, value1, valu2, valu3, valu4, value5, value6, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void triggrBattleFunction_async(BattleIce.AMD_XmdsManager_triggrBattleFunction cb__, string playerId, int eventId, int value1, int valu2, int valu3, int valu4, int value5, int value6, Ice.Current current__);
+
+        public void addUnits_async(BattleIce.AMD_XmdsManager_addUnits cb__, string instanceId, string data)
+        {
+            addUnits_async(cb__, instanceId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void addUnits_async(BattleIce.AMD_XmdsManager_addUnits cb__, string instanceId, string data, Ice.Current current__);
+
+        public void refreshPlayerPetFollowModeChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__, string playerId, int mode)
+        {
+            refreshPlayerPetFollowModeChange_async(cb__, playerId, mode, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshPlayerPetFollowModeChange_async(BattleIce.AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__, string playerId, int mode, Ice.Current current__);
+
+        public void playerReady_async(BattleIce.AMD_XmdsManager_playerReady cb__, string playerId)
+        {
+            playerReady_async(cb__, playerId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerReady_async(BattleIce.AMD_XmdsManager_playerReady cb__, string playerId, Ice.Current current__);
+
+        public void refreshTeamData_async(BattleIce.AMD_XmdsManager_refreshTeamData cb__, string playerId, string data)
+        {
+            refreshTeamData_async(cb__, playerId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void refreshTeamData_async(BattleIce.AMD_XmdsManager_refreshTeamData cb__, string playerId, string data, Ice.Current current__);
+
+        public void autoBattle_async(BattleIce.AMD_XmdsManager_autoBattle cb__, string instanceId, string playerId, bool enable)
+        {
+            autoBattle_async(cb__, instanceId, playerId, enable, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void autoBattle_async(BattleIce.AMD_XmdsManager_autoBattle cb__, string instanceId, string playerId, bool enable, Ice.Current current__);
+
+        public void getPlayerStatistic_async(BattleIce.AMD_XmdsManager_getPlayerStatistic cb__, string instanceId, string playerId, int flag)
+        {
+            getPlayerStatistic_async(cb__, instanceId, playerId, flag, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getPlayerStatistic_async(BattleIce.AMD_XmdsManager_getPlayerStatistic cb__, string instanceId, string playerId, int flag, Ice.Current current__);
+
+        public void getInstanceStatistic_async(BattleIce.AMD_XmdsManager_getInstanceStatistic cb__, string instanceId)
+        {
+            getInstanceStatistic_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getInstanceStatistic_async(BattleIce.AMD_XmdsManager_getInstanceStatistic cb__, string instanceId, Ice.Current current__);
+
+        public void addUnit_async(BattleIce.AMD_XmdsManager_addUnit cb__, string instanceId, int unitTemplateID, string data)
+        {
+            addUnit_async(cb__, instanceId, unitTemplateID, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void addUnit_async(BattleIce.AMD_XmdsManager_addUnit cb__, string instanceId, int unitTemplateID, string data, Ice.Current current__);
+
+        public void removeUnit_async(BattleIce.AMD_XmdsManager_removeUnit cb__, string instanceId, int unitId)
+        {
+            removeUnit_async(cb__, instanceId, unitId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void removeUnit_async(BattleIce.AMD_XmdsManager_removeUnit cb__, string instanceId, int unitId, Ice.Current current__);
+
+        public void removePointUnit_async(BattleIce.AMD_XmdsManager_removePointUnit cb__, string instanceId, int unitObjectId)
+        {
+            removePointUnit_async(cb__, instanceId, unitObjectId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void removePointUnit_async(BattleIce.AMD_XmdsManager_removePointUnit cb__, string instanceId, int unitObjectId, Ice.Current current__);
+
+        public void removeItem_async(BattleIce.AMD_XmdsManager_removeItem cb__, string instanceId, int itemId)
+        {
+            removeItem_async(cb__, instanceId, itemId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void removeItem_async(BattleIce.AMD_XmdsManager_removeItem cb__, string instanceId, int itemId, Ice.Current current__);
+
+        public void changePlayerState_async(BattleIce.AMD_XmdsManager_changePlayerState cb__, string instanceId, string playerId, byte status, int time)
+        {
+            changePlayerState_async(cb__, instanceId, playerId, status, time, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void changePlayerState_async(BattleIce.AMD_XmdsManager_changePlayerState cb__, string instanceId, string playerId, byte status, int time, Ice.Current current__);
+
+        public void playerChuanGong_async(BattleIce.AMD_XmdsManager_playerChuanGong cb__, string instanceId, string playerIdA, string playerIdB)
+        {
+            playerChuanGong_async(cb__, instanceId, playerIdA, playerIdB, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerChuanGong_async(BattleIce.AMD_XmdsManager_playerChuanGong cb__, string instanceId, string playerIdA, string playerIdB, Ice.Current current__);
+
+        public void mountainKingRefreshNotify_async(BattleIce.AMD_XmdsManager_mountainKingRefreshNotify cb__, string instanceId, string data)
+        {
+            mountainKingRefreshNotify_async(cb__, instanceId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void mountainKingRefreshNotify_async(BattleIce.AMD_XmdsManager_mountainKingRefreshNotify cb__, string instanceId, string data, Ice.Current current__);
+
+        #endregion
+
+        #region Slice type-related members
+
+        public static new readonly string[] ids__ = 
+        {
+            "::BattleIce::XmdsManager",
+            "::Ice::Object"
+        };
+
+        public override bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        public override string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        public override string ice_id()
+        {
+            return ids__[0];
+        }
+
+        public override string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        public static new string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus notifyBattleServer___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string name;
+            string data;
+            instanceId = is__.readString();
+            name = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_notifyBattleServer cb__ = new _AMD_XmdsManager_notifyBattleServer(inS__);
+            try
+            {
+                obj__.notifyBattleServer_async(cb__, instanceId, name, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getZoneStaticData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getZoneStaticData cb__ = new _AMD_XmdsManager_getZoneStaticData(inS__);
+            try
+            {
+                obj__.getZoneStaticData_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getZoneRegions___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getZoneRegions cb__ = new _AMD_XmdsManager_getZoneRegions(inS__);
+            try
+            {
+                obj__.getZoneRegions_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getBornPlace___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int areaId;
+            string pointId;
+            instanceId = is__.readString();
+            areaId = is__.readInt();
+            pointId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getBornPlace cb__ = new _AMD_XmdsManager_getBornPlace(inS__);
+            try
+            {
+                obj__.getBornPlace_async(cb__, instanceId, areaId, pointId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getAllUnitInfo___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getAllUnitInfo cb__ = new _AMD_XmdsManager_getAllUnitInfo(inS__);
+            try
+            {
+                obj__.getAllUnitInfo_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getAllNpcInfo___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getAllNpcInfo cb__ = new _AMD_XmdsManager_getAllNpcInfo(inS__);
+            try
+            {
+                obj__.getAllNpcInfo_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getAllPlayerUUID___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            inS__.readEmptyParams();
+            AMD_XmdsManager_getAllPlayerUUID cb__ = new _AMD_XmdsManager_getAllPlayerUUID(inS__);
+            try
+            {
+                obj__.getAllPlayerUUID_async(cb__, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getPlayerData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            bool changeArea;
+            playerId = is__.readString();
+            changeArea = is__.readBool();
+            inS__.endReadParams();
+            AMD_XmdsManager_getPlayerData cb__ = new _AMD_XmdsManager_getPlayerData(inS__);
+            try
+            {
+                obj__.getPlayerData_async(cb__, playerId, changeArea, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus onMonsterDiedDrops___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string data;
+            instanceId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_onMonsterDiedDrops cb__ = new _AMD_XmdsManager_onMonsterDiedDrops(inS__);
+            try
+            {
+                obj__.onMonsterDiedDrops_async(cb__, instanceId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus helpRevivePlayer___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string revivePlayerId;
+            int time;
+            playerId = is__.readString();
+            revivePlayerId = is__.readString();
+            time = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_helpRevivePlayer cb__ = new _AMD_XmdsManager_helpRevivePlayer(inS__);
+            try
+            {
+                obj__.helpRevivePlayer_async(cb__, playerId, revivePlayerId, time, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus revivePlayer___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_revivePlayer cb__ = new _AMD_XmdsManager_revivePlayer(inS__);
+            try
+            {
+                obj__.revivePlayer_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshSummonMount___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int time;
+            int isUp;
+            playerId = is__.readString();
+            time = is__.readInt();
+            isUp = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshSummonMount cb__ = new _AMD_XmdsManager_refreshSummonMount(inS__);
+            try
+            {
+                obj__.refreshSummonMount_async(cb__, playerId, time, isUp, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerBasicData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string basic;
+            playerId = is__.readString();
+            basic = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerBasicData cb__ = new _AMD_XmdsManager_refreshPlayerBasicData(inS__);
+            try
+            {
+                obj__.refreshPlayerBasicData_async(cb__, playerId, basic, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerTeamData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string uuidList;
+            playerId = is__.readString();
+            uuidList = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerTeamData cb__ = new _AMD_XmdsManager_refreshPlayerTeamData(inS__);
+            try
+            {
+                obj__.refreshPlayerTeamData_async(cb__, playerId, uuidList, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerRemainBagCountData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int remainCount;
+            playerId = is__.readString();
+            remainCount = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerRemainBagCountData cb__ = new _AMD_XmdsManager_refreshPlayerRemainBagCountData(inS__);
+            try
+            {
+                obj__.refreshPlayerRemainBagCountData_async(cb__, playerId, remainCount, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerRemainTeamBagCountData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int remainCount;
+            playerId = is__.readString();
+            remainCount = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__ = new _AMD_XmdsManager_refreshPlayerRemainTeamBagCountData(inS__);
+            try
+            {
+                obj__.refreshPlayerRemainTeamBagCountData_async(cb__, playerId, remainCount, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPetBaseInfoChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__ = new _AMD_XmdsManager_refreshPlayerPetBaseInfoChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPetBaseInfoChange_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPetDataChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int type;
+            string data;
+            playerId = is__.readString();
+            type = is__.readInt();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPetDataChange cb__ = new _AMD_XmdsManager_refreshPlayerPetDataChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPetDataChange_async(cb__, playerId, type, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerBattleEffect___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string effects;
+            playerId = is__.readString();
+            effects = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerBattleEffect cb__ = new _AMD_XmdsManager_refreshPlayerBattleEffect(inS__);
+            try
+            {
+                obj__.refreshPlayerBattleEffect_async(cb__, playerId, effects, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus addPlayerAtt___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string notifyPlayerIds;
+            string key;
+            int value;
+            playerId = is__.readString();
+            notifyPlayerIds = is__.readString();
+            key = is__.readString();
+            value = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_addPlayerAtt cb__ = new _AMD_XmdsManager_addPlayerAtt(inS__);
+            try
+            {
+                obj__.addPlayerAtt_async(cb__, playerId, notifyPlayerIds, key, value, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerSkill___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int operateID;
+            string skills;
+            playerId = is__.readString();
+            operateID = is__.readInt();
+            skills = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerSkill cb__ = new _AMD_XmdsManager_refreshPlayerSkill(inS__);
+            try
+            {
+                obj__.refreshPlayerSkill_async(cb__, playerId, operateID, skills, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerChangeSkill___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int oldSkillID;
+            int newSkillID;
+            string data;
+            playerId = is__.readString();
+            oldSkillID = is__.readInt();
+            newSkillID = is__.readInt();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_playerChangeSkill cb__ = new _AMD_XmdsManager_playerChangeSkill(inS__);
+            try
+            {
+                obj__.playerChangeSkill_async(cb__, playerId, oldSkillID, newSkillID, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerAvatar___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string avatars;
+            playerId = is__.readString();
+            avatars = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerAvatar cb__ = new _AMD_XmdsManager_refreshPlayerAvatar(inS__);
+            try
+            {
+                obj__.refreshPlayerAvatar_async(cb__, playerId, avatars, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getPlayerPKInfoData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            playerId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getPlayerPKInfoData cb__ = new _AMD_XmdsManager_getPlayerPKInfoData(inS__);
+            try
+            {
+                obj__.getPlayerPKInfoData_async(cb__, playerId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getPlayerSkillCDTime___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            playerId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getPlayerSkillCDTime cb__ = new _AMD_XmdsManager_getPlayerSkillCDTime(inS__);
+            try
+            {
+                obj__.getPlayerSkillCDTime_async(cb__, playerId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus canTalkWithNpc___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int npcId;
+            playerId = is__.readString();
+            npcId = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_canTalkWithNpc cb__ = new _AMD_XmdsManager_canTalkWithNpc(inS__);
+            try
+            {
+                obj__.canTalkWithNpc_async(cb__, playerId, npcId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPropertyChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPropertyChange cb__ = new _AMD_XmdsManager_refreshPlayerPropertyChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPropertyChange_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPKMode___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            bool isLook;
+            int mode;
+            playerId = is__.readString();
+            isLook = is__.readBool();
+            mode = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPKMode cb__ = new _AMD_XmdsManager_refreshPlayerPKMode(inS__);
+            try
+            {
+                obj__.refreshPlayerPKMode_async(cb__, playerId, isLook, mode, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPKValue___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int value;
+            playerId = is__.readString();
+            value = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPKValue cb__ = new _AMD_XmdsManager_refreshPlayerPKValue(inS__);
+            try
+            {
+                obj__.refreshPlayerPKValue_async(cb__, playerId, value, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPKLevel___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int level;
+            playerId = is__.readString();
+            level = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPKLevel cb__ = new _AMD_XmdsManager_refreshPlayerPKLevel(inS__);
+            try
+            {
+                obj__.refreshPlayerPKLevel_async(cb__, playerId, level, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus onFinishPickItem___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_onFinishPickItem cb__ = new _AMD_XmdsManager_onFinishPickItem(inS__);
+            try
+            {
+                obj__.onFinishPickItem_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPetSkillChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int operateID;
+            string skills;
+            playerId = is__.readString();
+            operateID = is__.readInt();
+            skills = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPetSkillChange cb__ = new _AMD_XmdsManager_refreshPlayerPetSkillChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPetSkillChange_async(cb__, playerId, operateID, skills, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus canUseItem___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            playerId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_canUseItem cb__ = new _AMD_XmdsManager_canUseItem(inS__);
+            try
+            {
+                obj__.canUseItem_async(cb__, playerId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus transferToPointPos___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string playerId;
+            string point;
+            bool setDirection;
+            float direction;
+            instanceId = is__.readString();
+            playerId = is__.readString();
+            point = is__.readString();
+            setDirection = is__.readBool();
+            direction = is__.readFloat();
+            inS__.endReadParams();
+            AMD_XmdsManager_transferToPointPos cb__ = new _AMD_XmdsManager_transferToPointPos(inS__);
+            try
+            {
+                obj__.transferToPointPos_async(cb__, instanceId, playerId, point, setDirection, direction, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPetPropertyChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPetPropertyChange cb__ = new _AMD_XmdsManager_refreshPlayerPetPropertyChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPetPropertyChange_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getPlayerPetData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            playerId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getPlayerPetData cb__ = new _AMD_XmdsManager_getPlayerPetData(inS__);
+            try
+            {
+                obj__.getPlayerPetData_async(cb__, playerId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus triggrBattleFunction___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int eventId;
+            int value1;
+            int valu2;
+            int valu3;
+            int valu4;
+            int value5;
+            int value6;
+            playerId = is__.readString();
+            eventId = is__.readInt();
+            value1 = is__.readInt();
+            valu2 = is__.readInt();
+            valu3 = is__.readInt();
+            valu4 = is__.readInt();
+            value5 = is__.readInt();
+            value6 = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_triggrBattleFunction cb__ = new _AMD_XmdsManager_triggrBattleFunction(inS__);
+            try
+            {
+                obj__.triggrBattleFunction_async(cb__, playerId, eventId, value1, valu2, valu3, valu4, value5, value6, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus addUnits___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string data;
+            instanceId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_addUnits cb__ = new _AMD_XmdsManager_addUnits(inS__);
+            try
+            {
+                obj__.addUnits_async(cb__, instanceId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshPlayerPetFollowModeChange___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            int mode;
+            playerId = is__.readString();
+            mode = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__ = new _AMD_XmdsManager_refreshPlayerPetFollowModeChange(inS__);
+            try
+            {
+                obj__.refreshPlayerPetFollowModeChange_async(cb__, playerId, mode, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerReady___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            playerId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_playerReady cb__ = new _AMD_XmdsManager_playerReady(inS__);
+            try
+            {
+                obj__.playerReady_async(cb__, playerId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus refreshTeamData___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string data;
+            playerId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_refreshTeamData cb__ = new _AMD_XmdsManager_refreshTeamData(inS__);
+            try
+            {
+                obj__.refreshTeamData_async(cb__, playerId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus autoBattle___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string playerId;
+            bool enable;
+            instanceId = is__.readString();
+            playerId = is__.readString();
+            enable = is__.readBool();
+            inS__.endReadParams();
+            AMD_XmdsManager_autoBattle cb__ = new _AMD_XmdsManager_autoBattle(inS__);
+            try
+            {
+                obj__.autoBattle_async(cb__, instanceId, playerId, enable, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getPlayerStatistic___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string playerId;
+            int flag;
+            instanceId = is__.readString();
+            playerId = is__.readString();
+            flag = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_getPlayerStatistic cb__ = new _AMD_XmdsManager_getPlayerStatistic(inS__);
+            try
+            {
+                obj__.getPlayerStatistic_async(cb__, instanceId, playerId, flag, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getInstanceStatistic___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_getInstanceStatistic cb__ = new _AMD_XmdsManager_getInstanceStatistic(inS__);
+            try
+            {
+                obj__.getInstanceStatistic_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus addUnit___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int unitTemplateID;
+            string data;
+            instanceId = is__.readString();
+            unitTemplateID = is__.readInt();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_addUnit cb__ = new _AMD_XmdsManager_addUnit(inS__);
+            try
+            {
+                obj__.addUnit_async(cb__, instanceId, unitTemplateID, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus removeUnit___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int unitId;
+            instanceId = is__.readString();
+            unitId = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_removeUnit cb__ = new _AMD_XmdsManager_removeUnit(inS__);
+            try
+            {
+                obj__.removeUnit_async(cb__, instanceId, unitId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus removePointUnit___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int unitObjectId;
+            instanceId = is__.readString();
+            unitObjectId = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_removePointUnit cb__ = new _AMD_XmdsManager_removePointUnit(inS__);
+            try
+            {
+                obj__.removePointUnit_async(cb__, instanceId, unitObjectId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus removeItem___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int itemId;
+            instanceId = is__.readString();
+            itemId = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_removeItem cb__ = new _AMD_XmdsManager_removeItem(inS__);
+            try
+            {
+                obj__.removeItem_async(cb__, instanceId, itemId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus changePlayerState___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string playerId;
+            byte status;
+            int time;
+            instanceId = is__.readString();
+            playerId = is__.readString();
+            status = is__.readByte();
+            time = is__.readInt();
+            inS__.endReadParams();
+            AMD_XmdsManager_changePlayerState cb__ = new _AMD_XmdsManager_changePlayerState(inS__);
+            try
+            {
+                obj__.changePlayerState_async(cb__, instanceId, playerId, status, time, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerChuanGong___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string playerIdA;
+            string playerIdB;
+            instanceId = is__.readString();
+            playerIdA = is__.readString();
+            playerIdB = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_playerChuanGong cb__ = new _AMD_XmdsManager_playerChuanGong(inS__);
+            try
+            {
+                obj__.playerChuanGong_async(cb__, instanceId, playerIdA, playerIdB, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus mountainKingRefreshNotify___(XmdsManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            string data;
+            instanceId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_XmdsManager_mountainKingRefreshNotify cb__ = new _AMD_XmdsManager_mountainKingRefreshNotify(inS__);
+            try
+            {
+                obj__.mountainKingRefreshNotify_async(cb__, instanceId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        private static string[] all__ =
+        {
+            "addPlayerAtt",
+            "addUnit",
+            "addUnits",
+            "autoBattle",
+            "canTalkWithNpc",
+            "canUseItem",
+            "changePlayerState",
+            "getAllNpcInfo",
+            "getAllPlayerUUID",
+            "getAllUnitInfo",
+            "getBornPlace",
+            "getInstanceStatistic",
+            "getPlayerData",
+            "getPlayerPKInfoData",
+            "getPlayerPetData",
+            "getPlayerSkillCDTime",
+            "getPlayerStatistic",
+            "getZoneRegions",
+            "getZoneStaticData",
+            "helpRevivePlayer",
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping",
+            "mountainKingRefreshNotify",
+            "notifyBattleServer",
+            "onFinishPickItem",
+            "onMonsterDiedDrops",
+            "playerChangeSkill",
+            "playerChuanGong",
+            "playerReady",
+            "refreshPlayerAvatar",
+            "refreshPlayerBasicData",
+            "refreshPlayerBattleEffect",
+            "refreshPlayerPKLevel",
+            "refreshPlayerPKMode",
+            "refreshPlayerPKValue",
+            "refreshPlayerPetBaseInfoChange",
+            "refreshPlayerPetDataChange",
+            "refreshPlayerPetFollowModeChange",
+            "refreshPlayerPetPropertyChange",
+            "refreshPlayerPetSkillChange",
+            "refreshPlayerPropertyChange",
+            "refreshPlayerRemainBagCountData",
+            "refreshPlayerRemainTeamBagCountData",
+            "refreshPlayerSkill",
+            "refreshPlayerTeamData",
+            "refreshSummonMount",
+            "refreshTeamData",
+            "removeItem",
+            "removePointUnit",
+            "removeUnit",
+            "revivePlayer",
+            "transferToPointPos",
+            "triggrBattleFunction"
+        };
+
+        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return addPlayerAtt___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return addUnit___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return addUnits___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return autoBattle___(this, inS__, current__);
+                }
+                case 4:
+                {
+                    return canTalkWithNpc___(this, inS__, current__);
+                }
+                case 5:
+                {
+                    return canUseItem___(this, inS__, current__);
+                }
+                case 6:
+                {
+                    return changePlayerState___(this, inS__, current__);
+                }
+                case 7:
+                {
+                    return getAllNpcInfo___(this, inS__, current__);
+                }
+                case 8:
+                {
+                    return getAllPlayerUUID___(this, inS__, current__);
+                }
+                case 9:
+                {
+                    return getAllUnitInfo___(this, inS__, current__);
+                }
+                case 10:
+                {
+                    return getBornPlace___(this, inS__, current__);
+                }
+                case 11:
+                {
+                    return getInstanceStatistic___(this, inS__, current__);
+                }
+                case 12:
+                {
+                    return getPlayerData___(this, inS__, current__);
+                }
+                case 13:
+                {
+                    return getPlayerPKInfoData___(this, inS__, current__);
+                }
+                case 14:
+                {
+                    return getPlayerPetData___(this, inS__, current__);
+                }
+                case 15:
+                {
+                    return getPlayerSkillCDTime___(this, inS__, current__);
+                }
+                case 16:
+                {
+                    return getPlayerStatistic___(this, inS__, current__);
+                }
+                case 17:
+                {
+                    return getZoneRegions___(this, inS__, current__);
+                }
+                case 18:
+                {
+                    return getZoneStaticData___(this, inS__, current__);
+                }
+                case 19:
+                {
+                    return helpRevivePlayer___(this, inS__, current__);
+                }
+                case 20:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 21:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 22:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 23:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+                case 24:
+                {
+                    return mountainKingRefreshNotify___(this, inS__, current__);
+                }
+                case 25:
+                {
+                    return notifyBattleServer___(this, inS__, current__);
+                }
+                case 26:
+                {
+                    return onFinishPickItem___(this, inS__, current__);
+                }
+                case 27:
+                {
+                    return onMonsterDiedDrops___(this, inS__, current__);
+                }
+                case 28:
+                {
+                    return playerChangeSkill___(this, inS__, current__);
+                }
+                case 29:
+                {
+                    return playerChuanGong___(this, inS__, current__);
+                }
+                case 30:
+                {
+                    return playerReady___(this, inS__, current__);
+                }
+                case 31:
+                {
+                    return refreshPlayerAvatar___(this, inS__, current__);
+                }
+                case 32:
+                {
+                    return refreshPlayerBasicData___(this, inS__, current__);
+                }
+                case 33:
+                {
+                    return refreshPlayerBattleEffect___(this, inS__, current__);
+                }
+                case 34:
+                {
+                    return refreshPlayerPKLevel___(this, inS__, current__);
+                }
+                case 35:
+                {
+                    return refreshPlayerPKMode___(this, inS__, current__);
+                }
+                case 36:
+                {
+                    return refreshPlayerPKValue___(this, inS__, current__);
+                }
+                case 37:
+                {
+                    return refreshPlayerPetBaseInfoChange___(this, inS__, current__);
+                }
+                case 38:
+                {
+                    return refreshPlayerPetDataChange___(this, inS__, current__);
+                }
+                case 39:
+                {
+                    return refreshPlayerPetFollowModeChange___(this, inS__, current__);
+                }
+                case 40:
+                {
+                    return refreshPlayerPetPropertyChange___(this, inS__, current__);
+                }
+                case 41:
+                {
+                    return refreshPlayerPetSkillChange___(this, inS__, current__);
+                }
+                case 42:
+                {
+                    return refreshPlayerPropertyChange___(this, inS__, current__);
+                }
+                case 43:
+                {
+                    return refreshPlayerRemainBagCountData___(this, inS__, current__);
+                }
+                case 44:
+                {
+                    return refreshPlayerRemainTeamBagCountData___(this, inS__, current__);
+                }
+                case 45:
+                {
+                    return refreshPlayerSkill___(this, inS__, current__);
+                }
+                case 46:
+                {
+                    return refreshPlayerTeamData___(this, inS__, current__);
+                }
+                case 47:
+                {
+                    return refreshSummonMount___(this, inS__, current__);
+                }
+                case 48:
+                {
+                    return refreshTeamData___(this, inS__, current__);
+                }
+                case 49:
+                {
+                    return removeItem___(this, inS__, current__);
+                }
+                case 50:
+                {
+                    return removePointUnit___(this, inS__, current__);
+                }
+                case 51:
+                {
+                    return removeUnit___(this, inS__, current__);
+                }
+                case 52:
+                {
+                    return revivePlayer___(this, inS__, current__);
+                }
+                case 53:
+                {
+                    return transferToPointPos___(this, inS__, current__);
+                }
+                case 54:
+                {
+                    return triggrBattleFunction___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        protected override void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.endWriteSlice();
+        }
+
+        protected override void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            is__.endReadSlice();
+        }
+
+        #endregion
+    }
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_notifyBattleServer : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_notifyBattleServer : IceInternal.IncomingAsync, AMD_XmdsManager_notifyBattleServer
+    {
+        public _AMD_XmdsManager_notifyBattleServer(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getZoneStaticData : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getZoneStaticData : IceInternal.IncomingAsync, AMD_XmdsManager_getZoneStaticData
+    {
+        public _AMD_XmdsManager_getZoneStaticData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getZoneRegions : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getZoneRegions : IceInternal.IncomingAsync, AMD_XmdsManager_getZoneRegions
+    {
+        public _AMD_XmdsManager_getZoneRegions(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getBornPlace : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getBornPlace : IceInternal.IncomingAsync, AMD_XmdsManager_getBornPlace
+    {
+        public _AMD_XmdsManager_getBornPlace(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getAllUnitInfo : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getAllUnitInfo : IceInternal.IncomingAsync, AMD_XmdsManager_getAllUnitInfo
+    {
+        public _AMD_XmdsManager_getAllUnitInfo(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getAllNpcInfo : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getAllNpcInfo : IceInternal.IncomingAsync, AMD_XmdsManager_getAllNpcInfo
+    {
+        public _AMD_XmdsManager_getAllNpcInfo(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getAllPlayerUUID : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getAllPlayerUUID : IceInternal.IncomingAsync, AMD_XmdsManager_getAllPlayerUUID
+    {
+        public _AMD_XmdsManager_getAllPlayerUUID(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getPlayerData : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getPlayerData : IceInternal.IncomingAsync, AMD_XmdsManager_getPlayerData
+    {
+        public _AMD_XmdsManager_getPlayerData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_onMonsterDiedDrops : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_onMonsterDiedDrops : IceInternal.IncomingAsync, AMD_XmdsManager_onMonsterDiedDrops
+    {
+        public _AMD_XmdsManager_onMonsterDiedDrops(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_helpRevivePlayer : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_helpRevivePlayer : IceInternal.IncomingAsync, AMD_XmdsManager_helpRevivePlayer
+    {
+        public _AMD_XmdsManager_helpRevivePlayer(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_revivePlayer : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_revivePlayer : IceInternal.IncomingAsync, AMD_XmdsManager_revivePlayer
+    {
+        public _AMD_XmdsManager_revivePlayer(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshSummonMount : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshSummonMount : IceInternal.IncomingAsync, AMD_XmdsManager_refreshSummonMount
+    {
+        public _AMD_XmdsManager_refreshSummonMount(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerBasicData : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerBasicData : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerBasicData
+    {
+        public _AMD_XmdsManager_refreshPlayerBasicData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerTeamData : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerTeamData : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerTeamData
+    {
+        public _AMD_XmdsManager_refreshPlayerTeamData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerRemainBagCountData : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerRemainBagCountData : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerRemainBagCountData
+    {
+        public _AMD_XmdsManager_refreshPlayerRemainBagCountData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerRemainTeamBagCountData : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerRemainTeamBagCountData : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerRemainTeamBagCountData
+    {
+        public _AMD_XmdsManager_refreshPlayerRemainTeamBagCountData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPetBaseInfoChange : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPetBaseInfoChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPetBaseInfoChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPetBaseInfoChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPetDataChange : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPetDataChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPetDataChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPetDataChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerBattleEffect : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerBattleEffect : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerBattleEffect
+    {
+        public _AMD_XmdsManager_refreshPlayerBattleEffect(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_addPlayerAtt : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_addPlayerAtt : IceInternal.IncomingAsync, AMD_XmdsManager_addPlayerAtt
+    {
+        public _AMD_XmdsManager_addPlayerAtt(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerSkill : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerSkill : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerSkill
+    {
+        public _AMD_XmdsManager_refreshPlayerSkill(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_playerChangeSkill : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_playerChangeSkill : IceInternal.IncomingAsync, AMD_XmdsManager_playerChangeSkill
+    {
+        public _AMD_XmdsManager_playerChangeSkill(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerAvatar : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerAvatar : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerAvatar
+    {
+        public _AMD_XmdsManager_refreshPlayerAvatar(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getPlayerPKInfoData : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getPlayerPKInfoData : IceInternal.IncomingAsync, AMD_XmdsManager_getPlayerPKInfoData
+    {
+        public _AMD_XmdsManager_getPlayerPKInfoData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getPlayerSkillCDTime : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getPlayerSkillCDTime : IceInternal.IncomingAsync, AMD_XmdsManager_getPlayerSkillCDTime
+    {
+        public _AMD_XmdsManager_getPlayerSkillCDTime(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_canTalkWithNpc : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_canTalkWithNpc : IceInternal.IncomingAsync, AMD_XmdsManager_canTalkWithNpc
+    {
+        public _AMD_XmdsManager_canTalkWithNpc(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPropertyChange : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPropertyChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPropertyChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPropertyChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPKMode : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPKMode : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPKMode
+    {
+        public _AMD_XmdsManager_refreshPlayerPKMode(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPKValue : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPKValue : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPKValue
+    {
+        public _AMD_XmdsManager_refreshPlayerPKValue(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPKLevel : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPKLevel : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPKLevel
+    {
+        public _AMD_XmdsManager_refreshPlayerPKLevel(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_onFinishPickItem : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_onFinishPickItem : IceInternal.IncomingAsync, AMD_XmdsManager_onFinishPickItem
+    {
+        public _AMD_XmdsManager_onFinishPickItem(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPetSkillChange : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPetSkillChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPetSkillChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPetSkillChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_canUseItem : Ice.AMDCallback
+    {
+        void ice_response(bool ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_canUseItem : IceInternal.IncomingAsync, AMD_XmdsManager_canUseItem
+    {
+        public _AMD_XmdsManager_canUseItem(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(bool ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeBool(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_transferToPointPos : Ice.AMDCallback
+    {
+        void ice_response(bool ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_transferToPointPos : IceInternal.IncomingAsync, AMD_XmdsManager_transferToPointPos
+    {
+        public _AMD_XmdsManager_transferToPointPos(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(bool ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeBool(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPetPropertyChange : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPetPropertyChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPetPropertyChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPetPropertyChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getPlayerPetData : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getPlayerPetData : IceInternal.IncomingAsync, AMD_XmdsManager_getPlayerPetData
+    {
+        public _AMD_XmdsManager_getPlayerPetData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_triggrBattleFunction : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_triggrBattleFunction : IceInternal.IncomingAsync, AMD_XmdsManager_triggrBattleFunction
+    {
+        public _AMD_XmdsManager_triggrBattleFunction(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_addUnits : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_addUnits : IceInternal.IncomingAsync, AMD_XmdsManager_addUnits
+    {
+        public _AMD_XmdsManager_addUnits(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshPlayerPetFollowModeChange : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshPlayerPetFollowModeChange : IceInternal.IncomingAsync, AMD_XmdsManager_refreshPlayerPetFollowModeChange
+    {
+        public _AMD_XmdsManager_refreshPlayerPetFollowModeChange(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_playerReady : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_playerReady : IceInternal.IncomingAsync, AMD_XmdsManager_playerReady
+    {
+        public _AMD_XmdsManager_playerReady(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_refreshTeamData : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_refreshTeamData : IceInternal.IncomingAsync, AMD_XmdsManager_refreshTeamData
+    {
+        public _AMD_XmdsManager_refreshTeamData(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_autoBattle : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_autoBattle : IceInternal.IncomingAsync, AMD_XmdsManager_autoBattle
+    {
+        public _AMD_XmdsManager_autoBattle(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getPlayerStatistic : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getPlayerStatistic : IceInternal.IncomingAsync, AMD_XmdsManager_getPlayerStatistic
+    {
+        public _AMD_XmdsManager_getPlayerStatistic(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_getInstanceStatistic : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_getInstanceStatistic : IceInternal.IncomingAsync, AMD_XmdsManager_getInstanceStatistic
+    {
+        public _AMD_XmdsManager_getInstanceStatistic(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_addUnit : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_addUnit : IceInternal.IncomingAsync, AMD_XmdsManager_addUnit
+    {
+        public _AMD_XmdsManager_addUnit(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_removeUnit : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_removeUnit : IceInternal.IncomingAsync, AMD_XmdsManager_removeUnit
+    {
+        public _AMD_XmdsManager_removeUnit(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_removePointUnit : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_removePointUnit : IceInternal.IncomingAsync, AMD_XmdsManager_removePointUnit
+    {
+        public _AMD_XmdsManager_removePointUnit(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_removeItem : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_removeItem : IceInternal.IncomingAsync, AMD_XmdsManager_removeItem
+    {
+        public _AMD_XmdsManager_removeItem(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_changePlayerState : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_changePlayerState : IceInternal.IncomingAsync, AMD_XmdsManager_changePlayerState
+    {
+        public _AMD_XmdsManager_changePlayerState(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_playerChuanGong : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_playerChuanGong : IceInternal.IncomingAsync, AMD_XmdsManager_playerChuanGong
+    {
+        public _AMD_XmdsManager_playerChuanGong(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_XmdsManager_mountainKingRefreshNotify : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_XmdsManager_mountainKingRefreshNotify : IceInternal.IncomingAsync, AMD_XmdsManager_mountainKingRefreshNotify
+    {
+        public _AMD_XmdsManager_mountainKingRefreshNotify(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+}

DotNet/Model/IceGenerate/ZoneManager.cs

@@ -0,0 +1,2823 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 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.6.4
+//
+// <auto-generated>
+//
+// Generated from file `ZoneManager.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+
+using _System = global::System;
+using _Microsoft = global::Microsoft;
+
+#pragma warning disable 1591
+
+namespace IceCompactId
+{
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+    public partial interface ZoneManagerCallback : Ice.Object, ZoneManagerCallbackOperations_, ZoneManagerCallbackOperationsNC_
+    {
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
+    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
+    public partial interface ZoneManager : Ice.Object, ZoneManagerOperations_, ZoneManagerOperationsNC_
+    {
+    }
+}
+
+namespace BattleIce
+{
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManagerCallback_eventNotify();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_setCallback(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_createZoneRequest(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_destroyZoneRequest();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_clearAllPlayersRequest();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_getAllPlayerCountRequest(int ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_playerEnterRequest();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_playerLeaveRequest();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_playerNetStateChanged();
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_getServerState(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_registerGameServer(string ret__);
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public delegate void Callback_ZoneManager_getUnitHP(int ret__);
+}
+
+namespace BattleIce
+{
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerCallbackPrx : Ice.ObjectPrx
+    {
+        void eventNotify(string eventType, string msg);
+
+        void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_eventNotify(string eventType, string msg, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_eventNotify(Ice.AsyncResult r__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerPrx : Ice.ObjectPrx
+    {
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        
+        int setCallback(Ice.Identity ident, string srvUUID);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        
+        int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="r__">The asynchronous result object for the invocation.</param>
+        int end_setCallback(Ice.AsyncResult r__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        
+        int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        
+        int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="r__">The asynchronous result object for the invocation.</param>
+        int end_createZoneRequest(Ice.AsyncResult r__);
+
+        void destroyZoneRequest(string instanceId);
+
+        void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_destroyZoneRequest(string instanceId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_destroyZoneRequest(Ice.AsyncResult r__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        
+        void clearAllPlayersRequest();
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        
+        void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest();
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_clearAllPlayersRequest(Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="ctx__">The Context map to send with the invocation.</param>
+        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
+        /// <returns>An asynchronous result object.</returns>
+        Ice.AsyncResult begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="r__">The asynchronous result object for the invocation.</param>
+        void end_clearAllPlayersRequest(Ice.AsyncResult r__);
+
+        int getAllPlayerCountRequest();
+
+        int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest();
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getAllPlayerCountRequest(Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_getAllPlayerCountRequest(Ice.AsyncResult r__);
+
+        void playerEnterRequest(string playerId, string instanceId, string data);
+
+        void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerEnterRequest(Ice.AsyncResult r__);
+
+        void playerLeaveRequest(string playerId, string instanceId, bool keepObject);
+
+        void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerLeaveRequest(Ice.AsyncResult r__);
+
+        void playerNetStateChanged(string playerId, string state);
+
+        void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        void end_playerNetStateChanged(Ice.AsyncResult r__);
+
+        string getServerState(string serverId);
+
+        string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getServerState(string serverId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_getServerState(Ice.AsyncResult r__);
+
+        string registerGameServer(int serverid, int crossid);
+
+        string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        string end_registerGameServer(Ice.AsyncResult r__);
+
+        int getUnitHP(string instanceId, int objectId);
+
+        int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId);
+
+        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__);
+
+        Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, Ice.AsyncCallback cb__, object cookie__);
+
+        Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);
+
+        int end_getUnitHP(Ice.AsyncResult r__);
+    }
+}
+
+namespace BattleIce
+{
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerCallbackOperations_
+    {
+        void eventNotify(string eventType, string msg, Ice.Current current__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerCallbackOperationsNC_
+    {
+        void eventNotify(string eventType, string msg);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerOperations_
+    {
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        /// <param name="current__">The Current object for the invocation.</param>
+        
+        int setCallback(Ice.Identity ident, string srvUUID, Ice.Current current__);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="cb__">The callback object for the operation.</param>
+        /// <param name="current__">The Current object for the invocation.</param>
+        void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.Current current__);
+
+        void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId, Ice.Current current__);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="cb__">The callback object for the operation.</param>
+        /// <param name="current__">The Current object for the invocation.</param>
+        void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__, Ice.Current current__);
+
+        void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__, Ice.Current current__);
+
+        void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data, Ice.Current current__);
+
+        void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject, Ice.Current current__);
+
+        void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state, Ice.Current current__);
+
+        void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId, Ice.Current current__);
+
+        void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid, Ice.Current current__);
+
+        void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId, Ice.Current current__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface ZoneManagerOperationsNC_
+    {
+        /// <summary>
+        /// 场景管理器相关协议
+        /// </summary>
+        
+        int setCallback(Ice.Identity ident, string srvUUID);
+
+        /// <summary>
+        /// 场景副本相关协议
+        /// </summary>
+        /// <param name="cb__">The callback object for the operation.</param>
+        void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);
+
+        void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId);
+
+        /// <summary>
+        /// 玩家相关协议
+        /// </summary>
+        /// <param name="cb__">The callback object for the operation.</param>
+        void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__);
+
+        void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__);
+
+        void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data);
+
+        void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject);
+
+        void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state);
+
+        void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId);
+
+        void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid);
+
+        void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId);
+    }
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class ZoneManagerCallbackPrxHelper : Ice.ObjectPrxHelperBase, ZoneManagerCallbackPrx
+    {
+        #region Synchronous operations
+
+        public void eventNotify(string eventType, string msg)
+        {
+            this.eventNotify(eventType, msg, null, false);
+        }
+
+        public void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.eventNotify(eventType, msg, ctx__, true);
+        }
+
+        private void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_eventNotify(begin_eventNotify(eventType, msg, context__, explicitCtx__, true, null, null));
+        }
+
+        #endregion
+
+        #region Asynchronous operations
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg)
+        {
+            return begin_eventNotify(eventType, msg, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_eventNotify(eventType, msg, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_eventNotify(string eventType, string msg, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_eventNotify(eventType, msg, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_eventNotify(eventType, msg, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __eventNotify_name = "eventNotify";
+
+        public void end_eventNotify(Ice.AsyncResult r__)
+        {
+            end__(r__, __eventNotify_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManagerCallback_eventNotify> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManagerCallback_eventNotify>(__eventNotify_name, eventNotify_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__eventNotify_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(eventType);
+                os__.writeString(msg);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void eventNotify_completed__(BattleIce.Callback_ZoneManagerCallback_eventNotify cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static ZoneManagerCallbackPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
+            if(r == null)
+            {
+                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerCallbackPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::ZoneManagerCallback",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, ZoneManagerCallbackPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static ZoneManagerCallbackPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                ZoneManagerCallbackPrxHelper result = new ZoneManagerCallbackPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public sealed class ZoneManagerPrxHelper : Ice.ObjectPrxHelperBase, ZoneManagerPrx
+    {
+        #region Synchronous operations
+
+        public void clearAllPlayersRequest()
+        {
+            this.clearAllPlayersRequest(null, false);
+        }
+
+        public void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.clearAllPlayersRequest(ctx__, true);
+        }
+
+        private void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_clearAllPlayersRequest(begin_clearAllPlayersRequest(context__, explicitCtx__, true, null, null));
+        }
+
+        public int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
+        {
+            return this.createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false);
+        }
+
+        public int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true);
+        }
+
+        private int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__createZoneRequest_name);
+            return end_createZoneRequest(begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void destroyZoneRequest(string instanceId)
+        {
+            this.destroyZoneRequest(instanceId, null, false);
+        }
+
+        public void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.destroyZoneRequest(instanceId, ctx__, true);
+        }
+
+        private void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_destroyZoneRequest(begin_destroyZoneRequest(instanceId, context__, explicitCtx__, true, null, null));
+        }
+
+        public int getAllPlayerCountRequest()
+        {
+            return this.getAllPlayerCountRequest(null, false);
+        }
+
+        public int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getAllPlayerCountRequest(ctx__, true);
+        }
+
+        private int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getAllPlayerCountRequest_name);
+            return end_getAllPlayerCountRequest(begin_getAllPlayerCountRequest(context__, explicitCtx__, true, null, null));
+        }
+
+        public string getServerState(string serverId)
+        {
+            return this.getServerState(serverId, null, false);
+        }
+
+        public string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getServerState(serverId, ctx__, true);
+        }
+
+        private string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getServerState_name);
+            return end_getServerState(begin_getServerState(serverId, context__, explicitCtx__, true, null, null));
+        }
+
+        public int getUnitHP(string instanceId, int objectId)
+        {
+            return this.getUnitHP(instanceId, objectId, null, false);
+        }
+
+        public int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.getUnitHP(instanceId, objectId, ctx__, true);
+        }
+
+        private int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__getUnitHP_name);
+            return end_getUnitHP(begin_getUnitHP(instanceId, objectId, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerEnterRequest(string playerId, string instanceId, string data)
+        {
+            this.playerEnterRequest(playerId, instanceId, data, null, false);
+        }
+
+        public void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerEnterRequest(playerId, instanceId, data, ctx__, true);
+        }
+
+        private void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerEnterRequest(begin_playerEnterRequest(playerId, instanceId, data, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerLeaveRequest(string playerId, string instanceId, bool keepObject)
+        {
+            this.playerLeaveRequest(playerId, instanceId, keepObject, null, false);
+        }
+
+        public void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true);
+        }
+
+        private void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerLeaveRequest(begin_playerLeaveRequest(playerId, instanceId, keepObject, context__, explicitCtx__, true, null, null));
+        }
+
+        public void playerNetStateChanged(string playerId, string state)
+        {
+            this.playerNetStateChanged(playerId, state, null, false);
+        }
+
+        public void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            this.playerNetStateChanged(playerId, state, ctx__, true);
+        }
+
+        private void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            end_playerNetStateChanged(begin_playerNetStateChanged(playerId, state, context__, explicitCtx__, true, null, null));
+        }
+
+        public string registerGameServer(int serverid, int crossid)
+        {
+            return this.registerGameServer(serverid, crossid, null, false);
+        }
+
+        public string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.registerGameServer(serverid, crossid, ctx__, true);
+        }
+
+        private string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__registerGameServer_name);
+            return end_registerGameServer(begin_registerGameServer(serverid, crossid, context__, explicitCtx__, true, null, null));
+        }
+
+        public int setCallback(Ice.Identity ident, string srvUUID)
+        {
+            return this.setCallback(ident, srvUUID, null, false);
+        }
+
+        public int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return this.setCallback(ident, srvUUID, ctx__, true);
+        }
+
+        private int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
+        {
+            checkTwowayOnly__(__setCallback_name);
+            return end_setCallback(begin_setCallback(ident, srvUUID, context__, explicitCtx__, true, null, null));
+        }
+
+        #endregion
+
+        #region Asynchronous operations
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest()
+        {
+            return begin_clearAllPlayersRequest(null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_clearAllPlayersRequest(ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_clearAllPlayersRequest(Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_clearAllPlayersRequest(null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_clearAllPlayersRequest(ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __clearAllPlayersRequest_name = "clearAllPlayersRequest";
+
+        public void end_clearAllPlayersRequest(Ice.AsyncResult r__)
+        {
+            end__(r__, __clearAllPlayersRequest_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_clearAllPlayersRequest>(__clearAllPlayersRequest_name, clearAllPlayersRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__clearAllPlayersRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                result__.writeEmptyParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void clearAllPlayersRequest_completed__(BattleIce.Callback_ZoneManager_clearAllPlayersRequest cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
+        {
+            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __createZoneRequest_name = "createZoneRequest";
+
+        public int end_createZoneRequest(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __createZoneRequest_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__createZoneRequest_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_createZoneRequest> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_createZoneRequest>(__createZoneRequest_name, createZoneRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__createZoneRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(gameServerId);
+                os__.writeInt(mapTemplateId);
+                os__.writeString(instanceId);
+                os__.writeBool(force);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void createZoneRequest_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_createZoneRequest cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_createZoneRequest(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId)
+        {
+            return begin_destroyZoneRequest(instanceId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_destroyZoneRequest(instanceId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_destroyZoneRequest(string instanceId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_destroyZoneRequest(instanceId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_destroyZoneRequest(instanceId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __destroyZoneRequest_name = "destroyZoneRequest";
+
+        public void end_destroyZoneRequest(Ice.AsyncResult r__)
+        {
+            end__(r__, __destroyZoneRequest_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_destroyZoneRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_destroyZoneRequest>(__destroyZoneRequest_name, destroyZoneRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__destroyZoneRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void destroyZoneRequest_completed__(BattleIce.Callback_ZoneManager_destroyZoneRequest cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest()
+        {
+            return begin_getAllPlayerCountRequest(null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getAllPlayerCountRequest(ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getAllPlayerCountRequest(Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllPlayerCountRequest(null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getAllPlayerCountRequest(ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getAllPlayerCountRequest_name = "getAllPlayerCountRequest";
+
+        public int end_getAllPlayerCountRequest(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getAllPlayerCountRequest_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getAllPlayerCountRequest_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest>(__getAllPlayerCountRequest_name, getAllPlayerCountRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getAllPlayerCountRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                result__.writeEmptyParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getAllPlayerCountRequest_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getAllPlayerCountRequest cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_getAllPlayerCountRequest(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId)
+        {
+            return begin_getServerState(serverId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getServerState(serverId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getServerState(string serverId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getServerState(serverId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getServerState(serverId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getServerState_name = "getServerState";
+
+        public string end_getServerState(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getServerState_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getServerState_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getServerState> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getServerState>(__getServerState_name, getServerState_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getServerState_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(serverId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getServerState_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getServerState cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_getServerState(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId)
+        {
+            return begin_getUnitHP(instanceId, objectId, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_getUnitHP(instanceId, objectId, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getUnitHP(instanceId, objectId, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_getUnitHP(instanceId, objectId, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __getUnitHP_name = "getUnitHP";
+
+        public int end_getUnitHP(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getUnitHP_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__getUnitHP_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getUnitHP> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getUnitHP>(__getUnitHP_name, getUnitHP_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__getUnitHP_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(instanceId);
+                os__.writeInt(objectId);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void getUnitHP_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getUnitHP cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_getUnitHP(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data)
+        {
+            return begin_playerEnterRequest(playerId, instanceId, data, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerEnterRequest(playerId, instanceId, data, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerEnterRequest(playerId, instanceId, data, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerEnterRequest(playerId, instanceId, data, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerEnterRequest_name = "playerEnterRequest";
+
+        public void end_playerEnterRequest(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerEnterRequest_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerEnterRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerEnterRequest>(__playerEnterRequest_name, playerEnterRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerEnterRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(instanceId);
+                os__.writeString(data);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerEnterRequest_completed__(BattleIce.Callback_ZoneManager_playerEnterRequest cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject)
+        {
+            return begin_playerLeaveRequest(playerId, instanceId, keepObject, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerLeaveRequest(playerId, instanceId, keepObject, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerLeaveRequest_name = "playerLeaveRequest";
+
+        public void end_playerLeaveRequest(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerLeaveRequest_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerLeaveRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerLeaveRequest>(__playerLeaveRequest_name, playerLeaveRequest_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerLeaveRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(instanceId);
+                os__.writeBool(keepObject);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerLeaveRequest_completed__(BattleIce.Callback_ZoneManager_playerLeaveRequest cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state)
+        {
+            return begin_playerNetStateChanged(playerId, state, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_playerNetStateChanged(playerId, state, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerNetStateChanged(playerId, state, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_playerNetStateChanged(playerId, state, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __playerNetStateChanged_name = "playerNetStateChanged";
+
+        public void end_playerNetStateChanged(Ice.AsyncResult r__)
+        {
+            end__(r__, __playerNetStateChanged_name);
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerNetStateChanged> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerNetStateChanged>(__playerNetStateChanged_name, playerNetStateChanged_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__playerNetStateChanged_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeString(playerId);
+                os__.writeString(state);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void playerNetStateChanged_completed__(BattleIce.Callback_ZoneManager_playerNetStateChanged cb__)
+        {
+            if(cb__ != null)
+            {
+                cb__();
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid)
+        {
+            return begin_registerGameServer(serverid, crossid, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_registerGameServer(serverid, crossid, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_registerGameServer(serverid, crossid, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_registerGameServer(serverid, crossid, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __registerGameServer_name = "registerGameServer";
+
+        public string end_registerGameServer(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __registerGameServer_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                string ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readString();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__registerGameServer_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_registerGameServer> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_registerGameServer>(__registerGameServer_name, registerGameServer_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__registerGameServer_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                os__.writeInt(serverid);
+                os__.writeInt(crossid);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void registerGameServer_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_registerGameServer cb__, Ice.ExceptionCallback excb__)
+        {
+            string ret__;
+            try
+            {
+                ret__ = end_registerGameServer(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID)
+        {
+            return begin_setCallback(ident, srvUUID, null, false, false, null, null);
+        }
+
+        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__)
+        {
+            return begin_setCallback(ident, srvUUID, ctx__, true, false, null, null);
+        }
+
+        public Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_setCallback(ident, srvUUID, null, false, false, cb__, cookie__);
+        }
+
+        public Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            return begin_setCallback(ident, srvUUID, ctx__, true, false, cb__, cookie__);
+        }
+
+        private const string __setCallback_name = "setCallback";
+
+        public int end_setCallback(Ice.AsyncResult r__)
+        {
+            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __setCallback_name);
+            try
+            {
+                if(!outAsync__.wait())
+                {
+                    try
+                    {
+                        outAsync__.throwUserException();
+                    }
+                    catch(Ice.UserException ex__)
+                    {
+                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
+                    }
+                }
+                int ret__;
+                IceInternal.BasicStream is__ = outAsync__.startReadParams();
+                ret__ = is__.readInt();
+                outAsync__.endReadParams();
+                return ret__;
+            }
+            finally
+            {
+                outAsync__.cacheMessageBuffers();
+            }
+        }
+
+        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
+        {
+            checkAsyncTwowayOnly__(__setCallback_name);
+            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_setCallback> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_setCallback>(__setCallback_name, setCallback_completed__, cookie__);
+            if(cb__ != null)
+            {
+                result__.whenCompletedWithAsyncCallback(cb__);
+            }
+            try
+            {
+                result__.prepare(__setCallback_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
+                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
+                Ice.Identity.write__(os__, ident);
+                os__.writeString(srvUUID);
+                result__.endWriteParams();
+                result__.invoke();
+            }
+            catch(Ice.Exception ex__)
+            {
+                result__.abort(ex__);
+            }
+            return result__;
+        }
+
+        private void setCallback_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_setCallback cb__, Ice.ExceptionCallback excb__)
+        {
+            int ret__;
+            try
+            {
+                ret__ = end_setCallback(r__);
+            }
+            catch(Ice.Exception ex__)
+            {
+                if(excb__ != null)
+                {
+                    excb__(ex__);
+                }
+                return;
+            }
+            if(cb__ != null)
+            {
+                cb__(ret__);
+            }
+        }
+
+        #endregion
+
+        #region Checked and unchecked cast operations
+
+        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerPrx r = b as ZoneManagerPrx;
+            if((r == null) && b.ice_isA(ice_staticId()))
+            {
+                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerPrx r = b as ZoneManagerPrx;
+            if((r == null) && b.ice_isA(ice_staticId(), ctx))
+            {
+                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId()))
+                {
+                    ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            try
+            {
+                if(bb.ice_isA(ice_staticId(), ctx))
+                {
+                    ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+                    h.copyFrom__(bb);
+                    return h;
+                }
+            }
+            catch(Ice.FacetNotExistException)
+            {
+            }
+            return null;
+        }
+
+        public static ZoneManagerPrx uncheckedCast(Ice.ObjectPrx b)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            ZoneManagerPrx r = b as ZoneManagerPrx;
+            if(r == null)
+            {
+                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+                h.copyFrom__(b);
+                r = h;
+            }
+            return r;
+        }
+
+        public static ZoneManagerPrx uncheckedCast(Ice.ObjectPrx b, string f)
+        {
+            if(b == null)
+            {
+                return null;
+            }
+            Ice.ObjectPrx bb = b.ice_facet(f);
+            ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
+            h.copyFrom__(bb);
+            return h;
+        }
+
+        public static readonly string[] ids__ =
+        {
+            "::BattleIce::ZoneManager",
+            "::Ice::Object"
+        };
+
+        public static string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        public static void write__(IceInternal.BasicStream os__, ZoneManagerPrx v__)
+        {
+            os__.writeProxy(v__);
+        }
+
+        public static ZoneManagerPrx read__(IceInternal.BasicStream is__)
+        {
+            Ice.ObjectPrx proxy = is__.readProxy();
+            if(proxy != null)
+            {
+                ZoneManagerPrxHelper result = new ZoneManagerPrxHelper();
+                result.copyFrom__(proxy);
+                return result;
+            }
+            return null;
+        }
+
+        #endregion
+    }
+}
+
+namespace BattleIce
+{
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public abstract class ZoneManagerCallbackDisp_ : Ice.ObjectImpl, ZoneManagerCallback
+    {
+        #region Slice operations
+
+        public void eventNotify(string eventType, string msg)
+        {
+            eventNotify(eventType, msg, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void eventNotify(string eventType, string msg, Ice.Current current__);
+
+        #endregion
+
+        #region Slice type-related members
+
+        public static new readonly string[] ids__ = 
+        {
+            "::BattleIce::ZoneManagerCallback",
+            "::Ice::Object"
+        };
+
+        public override bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        public override string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        public override string ice_id()
+        {
+            return ids__[0];
+        }
+
+        public override string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        public static new string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus eventNotify___(ZoneManagerCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string eventType;
+            string msg;
+            eventType = is__.readString();
+            msg = is__.readString();
+            inS__.endReadParams();
+            obj__.eventNotify(eventType, msg, current__);
+            inS__.writeEmptyParams__();
+            return Ice.DispatchStatus.DispatchOK;
+        }
+
+        private static string[] all__ =
+        {
+            "eventNotify",
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping"
+        };
+
+        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return eventNotify___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 4:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        protected override void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.endWriteSlice();
+        }
+
+        protected override void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            is__.endReadSlice();
+        }
+
+        #endregion
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public abstract class ZoneManagerDisp_ : Ice.ObjectImpl, ZoneManager
+    {
+        #region Slice operations
+
+        public int setCallback(Ice.Identity ident, string srvUUID)
+        {
+            return setCallback(ident, srvUUID, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract int setCallback(Ice.Identity ident, string srvUUID, Ice.Current current__);
+
+        public void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
+        {
+            createZoneRequest_async(cb__, playerId, gameServerId, mapTemplateId, instanceId, force, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.Current current__);
+
+        public void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId)
+        {
+            destroyZoneRequest_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId, Ice.Current current__);
+
+        public void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__)
+        {
+            clearAllPlayersRequest_async(cb__, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__, Ice.Current current__);
+
+        public void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__)
+        {
+            getAllPlayerCountRequest_async(cb__, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__, Ice.Current current__);
+
+        public void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data)
+        {
+            playerEnterRequest_async(cb__, playerId, instanceId, data, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data, Ice.Current current__);
+
+        public void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject)
+        {
+            playerLeaveRequest_async(cb__, playerId, instanceId, keepObject, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject, Ice.Current current__);
+
+        public void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state)
+        {
+            playerNetStateChanged_async(cb__, playerId, state, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state, Ice.Current current__);
+
+        public void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId)
+        {
+            getServerState_async(cb__, serverId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId, Ice.Current current__);
+
+        public void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid)
+        {
+            registerGameServer_async(cb__, serverid, crossid, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid, Ice.Current current__);
+
+        public void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId)
+        {
+            getUnitHP_async(cb__, instanceId, objectId, Ice.ObjectImpl.defaultCurrent);
+        }
+
+        public abstract void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId, Ice.Current current__);
+
+        #endregion
+
+        #region Slice type-related members
+
+        public static new readonly string[] ids__ = 
+        {
+            "::BattleIce::ZoneManager",
+            "::Ice::Object"
+        };
+
+        public override bool ice_isA(string s)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override bool ice_isA(string s, Ice.Current current__)
+        {
+            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
+        }
+
+        public override string[] ice_ids()
+        {
+            return ids__;
+        }
+
+        public override string[] ice_ids(Ice.Current current__)
+        {
+            return ids__;
+        }
+
+        public override string ice_id()
+        {
+            return ids__[0];
+        }
+
+        public override string ice_id(Ice.Current current__)
+        {
+            return ids__[0];
+        }
+
+        public static new string ice_staticId()
+        {
+            return ids__[0];
+        }
+
+        #endregion
+
+        #region Operation dispatch
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus setCallback___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            Ice.Identity ident;
+            ident = null;
+            string srvUUID;
+            ident = Ice.Identity.read__(is__, ident);
+            srvUUID = is__.readString();
+            inS__.endReadParams();
+            int ret__ = obj__.setCallback(ident, srvUUID, current__);
+            IceInternal.BasicStream os__ = inS__.startWriteParams__(Ice.FormatType.DefaultFormat);
+            os__.writeInt(ret__);
+            inS__.endWriteParams__(true);
+            return Ice.DispatchStatus.DispatchOK;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus createZoneRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string gameServerId;
+            int mapTemplateId;
+            string instanceId;
+            bool force;
+            string data;
+            playerId = is__.readString();
+            gameServerId = is__.readString();
+            mapTemplateId = is__.readInt();
+            instanceId = is__.readString();
+            force = is__.readBool();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_ZoneManager_createZoneRequest cb__ = new _AMD_ZoneManager_createZoneRequest(inS__);
+            try
+            {
+                obj__.createZoneRequest_async(cb__, playerId, gameServerId, mapTemplateId, instanceId, force, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus destroyZoneRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            instanceId = is__.readString();
+            inS__.endReadParams();
+            AMD_ZoneManager_destroyZoneRequest cb__ = new _AMD_ZoneManager_destroyZoneRequest(inS__);
+            try
+            {
+                obj__.destroyZoneRequest_async(cb__, instanceId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus clearAllPlayersRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            inS__.readEmptyParams();
+            AMD_ZoneManager_clearAllPlayersRequest cb__ = new _AMD_ZoneManager_clearAllPlayersRequest(inS__);
+            try
+            {
+                obj__.clearAllPlayersRequest_async(cb__, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getAllPlayerCountRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            inS__.readEmptyParams();
+            AMD_ZoneManager_getAllPlayerCountRequest cb__ = new _AMD_ZoneManager_getAllPlayerCountRequest(inS__);
+            try
+            {
+                obj__.getAllPlayerCountRequest_async(cb__, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerEnterRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string instanceId;
+            string data;
+            playerId = is__.readString();
+            instanceId = is__.readString();
+            data = is__.readString();
+            inS__.endReadParams();
+            AMD_ZoneManager_playerEnterRequest cb__ = new _AMD_ZoneManager_playerEnterRequest(inS__);
+            try
+            {
+                obj__.playerEnterRequest_async(cb__, playerId, instanceId, data, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerLeaveRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string instanceId;
+            bool keepObject;
+            playerId = is__.readString();
+            instanceId = is__.readString();
+            keepObject = is__.readBool();
+            inS__.endReadParams();
+            AMD_ZoneManager_playerLeaveRequest cb__ = new _AMD_ZoneManager_playerLeaveRequest(inS__);
+            try
+            {
+                obj__.playerLeaveRequest_async(cb__, playerId, instanceId, keepObject, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus playerNetStateChanged___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string playerId;
+            string state;
+            playerId = is__.readString();
+            state = is__.readString();
+            inS__.endReadParams();
+            AMD_ZoneManager_playerNetStateChanged cb__ = new _AMD_ZoneManager_playerNetStateChanged(inS__);
+            try
+            {
+                obj__.playerNetStateChanged_async(cb__, playerId, state, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getServerState___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string serverId;
+            serverId = is__.readString();
+            inS__.endReadParams();
+            AMD_ZoneManager_getServerState cb__ = new _AMD_ZoneManager_getServerState(inS__);
+            try
+            {
+                obj__.getServerState_async(cb__, serverId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus registerGameServer___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            int serverid;
+            int crossid;
+            serverid = is__.readInt();
+            crossid = is__.readInt();
+            inS__.endReadParams();
+            AMD_ZoneManager_registerGameServer cb__ = new _AMD_ZoneManager_registerGameServer(inS__);
+            try
+            {
+                obj__.registerGameServer_async(cb__, serverid, crossid, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
+        public static Ice.DispatchStatus getUnitHP___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
+            IceInternal.BasicStream is__ = inS__.startReadParams();
+            string instanceId;
+            int objectId;
+            instanceId = is__.readString();
+            objectId = is__.readInt();
+            inS__.endReadParams();
+            AMD_ZoneManager_getUnitHP cb__ = new _AMD_ZoneManager_getUnitHP(inS__);
+            try
+            {
+                obj__.getUnitHP_async(cb__, instanceId, objectId, current__);
+            }
+            catch(_System.Exception ex__)
+            {
+                cb__.ice_exception(ex__);
+            }
+            return Ice.DispatchStatus.DispatchAsync;
+        }
+
+        private static string[] all__ =
+        {
+            "clearAllPlayersRequest",
+            "createZoneRequest",
+            "destroyZoneRequest",
+            "getAllPlayerCountRequest",
+            "getServerState",
+            "getUnitHP",
+            "ice_id",
+            "ice_ids",
+            "ice_isA",
+            "ice_ping",
+            "playerEnterRequest",
+            "playerLeaveRequest",
+            "playerNetStateChanged",
+            "registerGameServer",
+            "setCallback"
+        };
+
+        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
+        {
+            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
+            if(pos < 0)
+            {
+                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+            }
+
+            switch(pos)
+            {
+                case 0:
+                {
+                    return clearAllPlayersRequest___(this, inS__, current__);
+                }
+                case 1:
+                {
+                    return createZoneRequest___(this, inS__, current__);
+                }
+                case 2:
+                {
+                    return destroyZoneRequest___(this, inS__, current__);
+                }
+                case 3:
+                {
+                    return getAllPlayerCountRequest___(this, inS__, current__);
+                }
+                case 4:
+                {
+                    return getServerState___(this, inS__, current__);
+                }
+                case 5:
+                {
+                    return getUnitHP___(this, inS__, current__);
+                }
+                case 6:
+                {
+                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
+                }
+                case 7:
+                {
+                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
+                }
+                case 8:
+                {
+                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
+                }
+                case 9:
+                {
+                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
+                }
+                case 10:
+                {
+                    return playerEnterRequest___(this, inS__, current__);
+                }
+                case 11:
+                {
+                    return playerLeaveRequest___(this, inS__, current__);
+                }
+                case 12:
+                {
+                    return playerNetStateChanged___(this, inS__, current__);
+                }
+                case 13:
+                {
+                    return registerGameServer___(this, inS__, current__);
+                }
+                case 14:
+                {
+                    return setCallback___(this, inS__, current__);
+                }
+            }
+
+            _System.Diagnostics.Debug.Assert(false);
+            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
+        }
+
+        #endregion
+
+        #region Marshaling support
+
+        protected override void writeImpl__(IceInternal.BasicStream os__)
+        {
+            os__.startWriteSlice(ice_staticId(), -1, true);
+            os__.endWriteSlice();
+        }
+
+        protected override void readImpl__(IceInternal.BasicStream is__)
+        {
+            is__.startReadSlice();
+            is__.endReadSlice();
+        }
+
+        #endregion
+    }
+}
+
+namespace BattleIce
+{
+    /// <summary>
+    /// 场景副本相关协议
+    /// </summary>
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_createZoneRequest : Ice.AMDCallback
+    {
+        /// <summary>
+        /// ice_response indicates that
+        /// the operation completed successfully.
+        /// </summary>
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_createZoneRequest : IceInternal.IncomingAsync, AMD_ZoneManager_createZoneRequest
+    {
+        public _AMD_ZoneManager_createZoneRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_destroyZoneRequest : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_destroyZoneRequest : IceInternal.IncomingAsync, AMD_ZoneManager_destroyZoneRequest
+    {
+        public _AMD_ZoneManager_destroyZoneRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    /// <summary>
+    /// 玩家相关协议
+    /// </summary>
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_clearAllPlayersRequest : Ice.AMDCallback
+    {
+        /// <summary>
+        /// ice_response indicates that
+        /// the operation completed successfully.
+        /// </summary>
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_clearAllPlayersRequest : IceInternal.IncomingAsync, AMD_ZoneManager_clearAllPlayersRequest
+    {
+        public _AMD_ZoneManager_clearAllPlayersRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_getAllPlayerCountRequest : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_getAllPlayerCountRequest : IceInternal.IncomingAsync, AMD_ZoneManager_getAllPlayerCountRequest
+    {
+        public _AMD_ZoneManager_getAllPlayerCountRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_playerEnterRequest : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_playerEnterRequest : IceInternal.IncomingAsync, AMD_ZoneManager_playerEnterRequest
+    {
+        public _AMD_ZoneManager_playerEnterRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_playerLeaveRequest : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_playerLeaveRequest : IceInternal.IncomingAsync, AMD_ZoneManager_playerLeaveRequest
+    {
+        public _AMD_ZoneManager_playerLeaveRequest(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_playerNetStateChanged : Ice.AMDCallback
+    {
+        void ice_response();
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_playerNetStateChanged : IceInternal.IncomingAsync, AMD_ZoneManager_playerNetStateChanged
+    {
+        public _AMD_ZoneManager_playerNetStateChanged(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response()
+        {
+            if(validateResponse__(true))
+            {
+                writeEmptyParams__();
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_getServerState : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_getServerState : IceInternal.IncomingAsync, AMD_ZoneManager_getServerState
+    {
+        public _AMD_ZoneManager_getServerState(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_registerGameServer : Ice.AMDCallback
+    {
+        void ice_response(string ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_registerGameServer : IceInternal.IncomingAsync, AMD_ZoneManager_registerGameServer
+    {
+        public _AMD_ZoneManager_registerGameServer(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(string ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeString(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+
+    [_System.Runtime.InteropServices.ComVisible(false)]
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    public interface AMD_ZoneManager_getUnitHP : Ice.AMDCallback
+    {
+        void ice_response(int ret__);
+    }
+
+    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
+    class _AMD_ZoneManager_getUnitHP : IceInternal.IncomingAsync, AMD_ZoneManager_getUnitHP
+    {
+        public _AMD_ZoneManager_getUnitHP(IceInternal.Incoming inc) : base(inc)
+        {
+        }
+
+        public void ice_response(int ret__)
+        {
+            if(validateResponse__(true))
+            {
+                try
+                {
+                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
+                    os__.writeInt(ret__);
+                    endWriteParams__(true);
+                }
+                catch(Ice.LocalException ex__)
+                {
+                    exception__(ex__);
+                    return;
+                }
+                response__();
+            }
+        }
+    }
+}

DotNet/Model/Module/Global.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ET.Server
+{
+    public static class Global
+    {
+        [StaticField]
+        public static int GameServerId;
+
+        [StaticField]
+        public static string GameServerUUID;
+    }
+}

DotNet/Model/Module/IceBattle/BattleIceAgentComponent.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ET.Server
+{
+    [ComponentOf(typeof(Scene))]
+    public class BattleIceAgentComponent : Entity, IAwake, IDestroy
+    {
+        [StaticField]
+        public static BattleIceAgentComponent Instance;
+
+        public Ice.Application IceApp;
+        public BattleIce.ZoneManagerPrx IceZoneManager;
+        public BattleIce.XmdsManagerPrx IceXmdsManager;
+    }
+}

DotNet/library/Ice.xml

@@ -0,0 +1,8800 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Ice</name>
+    </assembly>
+    <members>
+        <member name="T:Ice.AMDCallback">
+            <summary>
+            AMDCallback is the interface from which all AMD callbacks are derived.
+            </summary>
+        </member>
+        <member name="M:Ice.AMDCallback.ice_exception(System.Exception)">
+            <summary>
+            Indicates to the Ice run time that an operation completed
+            with a run-time exception.
+            </summary>
+            <param name="ex">The encoded Ice run-time exception. Note that, if ex
+            is a user exception, the caller receives UnknownUserException.
+            Use ice_response to raise user exceptions.</param>
+        </member>
+        <member name="T:Ice.SignalPolicy">
+            <summary>
+            The signal policy for Ice.Application signal handling.
+            </summary>
+        </member>
+        <member name="F:Ice.SignalPolicy.HandleSignals">
+            <summary>
+            If a signal is received, Ice.Application reacts to the signal
+            by calling Communicator.destroy or Communicator.shutdown,
+            or by calling a custom shutdown hook installed by the application.
+            </summary>
+        </member>
+        <member name="F:Ice.SignalPolicy.NoSignalHandling">
+            <summary>
+            Any signal that is received is not intercepted and takes the default action.
+            </summary>
+        </member>
+        <member name="T:Ice.Application">
+            <summary>
+            Utility base class that makes it easy to correctly initialize and finalize
+            the Ice run time, as well as handle signals. Unless the application specifies
+            a logger, Application installs a per-process logger that logs to the standard
+            error output.
+            Applications must create a derived class that implements the run method.
+            A program can contain only one instance of this class.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.run(System.String[])">
+            <summary>
+            Called once the communicator has been initialized. The derived class must
+            implement run, which is the application's starting method.
+            </summary>
+            <param name="args">The argument vector for the application. Application
+            scans the argument vector passed to main for options that are
+            specific to the Ice run time and removes them; therefore, the vector passed
+            to run is free from Ice-related options and contains only options
+            and arguments that are application-specific.</param>
+            <returns>The run method should return zero for successful termination, and
+            non-zero otherwise. Application.main returns the value returned by run.</returns>
+        </member>
+        <member name="M:Ice.Application.interruptCallback(System.Int32)">
+            <summary>
+            Override this method to provide a custom application interrupt
+            hook. You must call callbackOnInterrupt for this method
+            to be called. Note that the interruptCallback can be called
+            concurrently with any other thread (including main) in your
+            application--take appropriate concurrency precautions.
+            </summary>
+            <param name="sig">The cause of the interrupt.</param>
+        </member>
+        <member name="M:Ice.Application.#ctor">
+            <summary>
+            Initializes an instance that calls Communicator.shutdown if a signal is received.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.#ctor(Ice.SignalPolicy)">
+            <summary>
+            Initializes an instance that handles signals according to the signal policy.
+            </summary>
+            <param name="signalPolicy">Determines how to respond to signals.</param>
+        </member>
+        <member name="M:Ice.Application.main(System.String[])">
+            <summary>
+            The application must call main after it has
+            instantiated the derived class. main creates
+            a communicator, establishes the specified signal policy, and,
+            once run returns, destroys the communicator.
+            The method prints an error message for any exception that propagates
+            out of run and ensures that the communicator is
+            destroyed correctly even if run completes abnormally.
+            </summary>
+            <param name="args">The arguments for the application (as passed to Main(string[])
+            by the operating system.</param>
+            <returns>The value returned by run. If run terminates with an exception,
+            the return value is non-zero.</returns>
+        </member>
+        <member name="M:Ice.Application.main(System.String[],System.String)">
+            <summary>
+            The application must call main after it has
+            instantiated the derived class. main creates
+            a communicator, establishes the specified signal policy, and,
+            once run returns, destroys the communicator.
+            The method prints an error message for any exception that propagates
+            out of run and ensures that the communicator is
+            destroyed correctly even if run completes abnormally.
+            </summary>
+            <param name="args">The arguments for the application (as passed to Main(string[])
+            by the operating system.</param>
+            <param name="configFile">The configuration file with which to initialize
+            Ice properties.</param>
+            <returns>The value returned by run. If run terminates with an exception,
+            the return value is non-zero.</returns>
+        </member>
+        <member name="M:Ice.Application.main(System.String[],Ice.InitializationData)">
+            <summary>
+            The application must call main after it has
+            instantiated the derived class. main creates
+            a communicator, establishes the specified signal policy, and,
+            once run returns, destroys the communicator.
+            The method prints an error message for any exception that propagates
+            out of run and ensures that the communicator is
+            destroyed correctly even if run completes abnormally.
+            </summary>
+            <param name="args">The arguments for the application (as passed to Main(string[])
+            by the operating system.</param>
+            <param name="initializationData">Additional data used to initialize the communicator.</param>
+            <returns>The value returned by run. If run terminates with an exception,
+            the return value is non-zero.</returns>
+        </member>
+        <member name="M:Ice.Application.appName">
+            <summary>
+            Returns the application name (which is also the value of Ice.ProgramName.
+            This method is useful mainly for error messages that
+            include the application name. Because appName is a static method, it is available from anywhere
+            in the program.
+            </summary>
+            <returns>The name of the application.</returns>
+        </member>
+        <member name="M:Ice.Application.communicator">
+            <summary>
+            Returns the communicator for the application. Because communicator is a static method,
+            it permits access to the communicator from anywhere in the program. Note that, as a consequence,
+            you cannot have more than one instance of Application in a program.
+            </summary>
+            <returns>The communicator for the application.</returns>
+        </member>
+        <member name="M:Ice.Application.destroyOnInterrupt">
+            <summary>
+            Instructs Application to call Communicator.destroy on receipt of a signal.
+            This is default signal handling policy established by the default constructor.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.shutdownOnInterrupt">
+            <summary>
+            Instructs Application to call Communicator.shutdown on receipt of a signal.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.ignoreInterrupt">
+            <summary>
+            Instructs Application to ignore signals.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.callbackOnInterrupt">
+            <summary>
+            Instructs Application to call interruptCallback on receipt of a signal.
+            The derived class can intercept signals by overriding interruptCallback.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.holdInterrupt">
+            <summary>
+            Instructs Application to call to hold signals.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.releaseInterrupt">
+            <summary>
+            Instructs Application respond to signals. If a signal arrived since the last call
+            to holdInterrupt, it is delivered once you call releaseInterrupt.
+            </summary>
+        </member>
+        <member name="M:Ice.Application.interrupted">
+            <summary>
+            Determines whether the application shut down intentionally or was forced to shut down due to a signal.
+            This is useful for logging purposes.
+            </summary>
+            <returns>True if a signal caused the communicator to shut down; false otherwise.</returns>
+        </member>
+        <member name="T:Ice.AsyncCallback">
+            
+             <summary>
+             Callback that requires the application to down-cast the proxy.
+             </summary>
+            
+        </member>
+        <member name="T:Ice.OnewayCallback">
+            
+             <summary>
+             Callback for the successful completion of an operation
+             that returns no data.
+             </summary>
+            
+        </member>
+        <member name="T:Ice.SentCallback">
+            
+             <summary>
+             Callback for the successful completion of an operation
+             that returns no data.
+             </summary>
+            
+        </member>
+        <member name="T:Ice.ExceptionCallback">
+            
+             <summary>
+             Called when an invocation raises an exception.
+             </summary>
+            
+        </member>
+        <member name="T:Ice.AsyncResult">
+            
+             <summary>
+             <!-- TODO -->
+             </summary>
+        </member>
+        <member name="M:Ice.BatchRequest.enqueue">
+            <summary>
+            Confirms the queuing of the batch request.
+            </summary>
+        </member>
+        <member name="M:Ice.BatchRequest.getSize">
+            <summary>
+            Get the marshalled size of the request.
+            </summary>
+            <returns>The request size.</returns>
+        </member>
+        <member name="M:Ice.BatchRequest.getOperation">
+            <summary>
+            Get the name of the operation
+            </summary>
+            <returns>The request operation.</returns>
+        </member>
+        <member name="M:Ice.BatchRequest.getProxy">
+            <summary>
+            The proxy used to invoke the batch request.
+            </summary>
+            <returns>The request proxy.</returns>
+        </member>
+        <member name="T:Ice.BatchRequestInterceptor">
+            <summary>
+            Base interface for listening to batch request queues.
+            </summary>
+        </member>
+        <member name="M:Ice.BatchRequestInterceptor.enqueue(Ice.BatchRequest,System.Int32,System.Int32)">
+             <summary>
+             Called by the Ice runtime when a batch request is about to be
+             added to the batch request queue of a proxy or connection.
+            
+             The implementation of this method must call enqueue() on the
+             request to confirm its addition to the queue, if not called
+             the request isn't added to the queue. The implementation can
+             raise an Ice local exception to notify the caller of a failure.
+             </summary>
+             <param name="request">The batch request.</param>
+             <param name="queueBatchRequestCount">The number of batch request queued.</param>
+             <param name="queueBatchRequestSize">The size of the queued batch requests.</param>
+        </member>
+        <member name="M:Ice.Communicator.destroy">
+            <summary>
+            Destroy the communicator.
+            This operation calls shutdown
+            implicitly.  Calling destroy cleans up memory, and shuts down
+            this communicator's client functionality and destroys all object
+            adapters. Subsequent calls to destroy are ignored.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.Communicator.shutdown">
+            <summary>
+            Shuts down this communicator's server functionality, which
+            includes the deactivation of all object adapters.
+            (Attempts to use
+            a deactivated object adapter raise ObjectAdapterDeactivatedException.)
+            Subsequent calls to shutdown are ignored.
+            
+             After shutdown returns, no new requests are
+            processed. However, requests that have been started before
+            shutdown was called might still be active. You can use
+            waitForShutdown to wait for the completion of all
+            requests.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.Communicator.waitForShutdown">
+            <summary>
+            Wait until the application has called shutdown (or destroy).
+            On the server side, this operation blocks the calling thread
+            until all currently-executing operations have completed.
+            On the client side, the operation simply block until another
+            thread has called shutdown or destroy.
+            
+            A typical use of this operation is to call it
+            from the main thread, which then waits until some other thread
+            calls shutdown. After shut-down is complete, the main thread
+            returns and can do some cleanup work before it finally calls
+            destroy to shut down the client functionality, and then
+            exits the application.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.Communicator.isShutdown">
+            <summary>
+            Check whether communicator has been shut down.
+            </summary>
+            <returns>True if the communicator has been shut down; false otherwise.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.stringToProxy(System.String)">
+            <summary>
+            Convert a stringified proxy into a proxy.
+            For example,
+            MyCategory/MyObject:tcp -h some_host -p
+            10000 creates a proxy that refers to the Ice object
+            having an identity with a name "MyObject" and a category
+            "MyCategory", with the server running on host "some_host", port
+            10000. If the stringified proxy does not parse correctly, the
+            operation throws one of ProxyParseException,
+            EndpointParseException, or IdentityParseException.
+            An appendix in the Ice manual provides a detailed description
+            of the syntax supported by stringified proxies.
+            
+            </summary>
+            <param name="str">The stringified proxy to convert into a proxy.
+            
+            </param>
+            <returns>The proxy, or nil if str is an empty string.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.proxyToString(Ice.ObjectPrx)">
+            <summary>
+            Convert a proxy into a string.
+            </summary>
+            <param name="obj">The proxy to convert into a stringified proxy.
+            
+            </param>
+            <returns>The stringified proxy, or an empty string if
+            obj is nil.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.propertyToProxy(System.String)">
+            <summary>
+            Convert a set of proxy properties into a proxy.
+            The "base"
+            name supplied in the property argument refers to a
+            property containing a stringified proxy, such as
+            MyProxy=id:tcp -h localhost -p 10000. Additional
+            properties configure local settings for the proxy, such as
+            MyProxy.PreferSecure=1. The "Properties"
+            appendix in the Ice manual describes each of the supported
+            proxy properties.
+            
+            </summary>
+            <param name="property">The base property name.
+            
+            </param>
+            <returns>The proxy.</returns>
+        </member>
+        <member name="M:Ice.Communicator.proxyToProperty(Ice.ObjectPrx,System.String)">
+            <summary>
+            Convert a proxy to a set of proxy properties.
+            </summary>
+            <param name="proxy">The proxy.
+            
+            </param>
+            <param name="property">The base property name.
+            
+            </param>
+            <returns>The property set.</returns>
+        </member>
+        <member name="M:Ice.Communicator.stringToIdentity(System.String)">
+            <summary>
+            Convert a string into an identity.
+            If the string does not parse
+            correctly, the operation throws IdentityParseException.
+            
+            </summary>
+            <param name="str">The string to convert into an identity.
+            
+            </param>
+            <returns>The identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.identityToString(Ice.Identity)">
+            <summary>
+            Convert an identity into a string.
+            </summary>
+            <param name="ident">The identity to convert into a string.
+            
+            </param>
+            <returns>The "stringified" identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.createObjectAdapter(System.String)">
+            <summary>
+            Create a new object adapter.
+            The endpoints for the object
+            adapter are taken from the property name.Endpoints.
+            
+            It is legal to create an object adapter with the empty string as
+            its name. Such an object adapter is accessible via bidirectional
+            connections or by collocated invocations that originate from the
+            same communicator as is used by the adapter.
+            
+            Attempts to create a named object adapter for which no configuration
+            can be found raise InitializationException.
+            
+            </summary>
+            <param name="name">The object adapter name.
+            
+            </param>
+            <returns>The new object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.createObjectAdapterWithEndpoints(System.String,System.String)">
+            <summary>
+            Create a new object adapter with endpoints.
+            This operation sets
+            the property name.Endpoints,
+            and then calls createObjectAdapter. It is provided as a
+            convenience function.
+            
+            Calling this operation with an empty name will result in a
+            UUID being generated for the name.
+            
+            </summary>
+            <param name="name">The object adapter name.
+            
+            </param>
+            <param name="endpoints">The endpoints for the object adapter.
+            
+            </param>
+            <returns>The new object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.createObjectAdapterWithRouter(System.String,Ice.RouterPrx)">
+            <summary>
+            Create a new object adapter with a router.
+            This operation
+            creates a routed object adapter.
+            
+            Calling this operation with an empty name will result in a
+            UUID being generated for the name.
+            
+            </summary>
+            <param name="name">The object adapter name.
+            
+            </param>
+            <param name="rtr">The router.
+            
+            </param>
+            <returns>The new object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.addObjectFactory(Ice.ObjectFactory,System.String)">
+            <summary>
+            Add an object factory to this communicator.
+            Installing a
+            factory with an id for which a factory is already registered
+            throws AlreadyRegisteredException.
+            
+            When unmarshaling an Ice object, the Ice run time reads the
+            most-derived type id off the wire and attempts to create an
+            instance of the type using a factory. If no instance is created,
+            either because no factory was found, or because all factories
+            returned nil, the behavior of the Ice run time depends on the
+            format with which the object was marshaled:
+            
+            If the object uses the "sliced" format, Ice ascends the class
+            hierarchy until it finds a type that is recognized by a factory,
+            or it reaches the least-derived type. If no factory is found that
+            can create an instance, the run time throws
+            NoObjectFactoryException.
+            
+            If the object uses the "compact" format, Ice immediately raises
+            NoObjectFactoryException.
+            
+            The following order is used to locate a factory for a type:
+            
+            
+            
+            The Ice run-time looks for a factory registered
+            specifically for the type.
+            
+            If no instance has been created, the Ice run-time looks
+            for the default factory, which is registered with an empty type id.
+            
+            
+            If no instance has been created by any of the preceding
+            steps, the Ice run-time looks for a factory that may have been
+            statically generated by the language mapping for non-abstract classes.
+            
+            
+            
+            
+            </summary>
+            <param name="factory">The factory to add.
+            
+            </param>
+            <param name="id">The type id for which the factory can create instances, or
+            an empty string for the default factory.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Communicator.findObjectFactory(System.String)">
+            <summary>
+            Find an object factory registered with this communicator.
+            </summary>
+            <param name="id">The type id for which the factory can create instances,
+            or an empty string for the default factory.
+            
+            </param>
+            <returns>The object factory, or null if no object factory was
+            found for the given id.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.getImplicitContext">
+            <summary>
+            Get the implicit context associated with this communicator.
+            </summary>
+            <returns>The implicit context associated with this communicator;
+            returns null when the property Ice.ImplicitContext is not set
+            or is set to None.</returns>
+        </member>
+        <member name="M:Ice.Communicator.getProperties">
+            <summary>
+            Get the properties for this communicator.
+            </summary>
+            <returns>This communicator's properties.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.getLogger">
+            <summary>
+            Get the logger for this communicator.
+            </summary>
+            <returns>This communicator's logger.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.getObserver">
+            <summary>
+            Get the observer resolver object for this communicator.
+            </summary>
+            <returns>This communicator's observer resolver object.</returns>
+        </member>
+        <member name="M:Ice.Communicator.getDefaultRouter">
+            <summary>
+            Get the default router this communicator.
+            </summary>
+            <returns>The default router for this communicator.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.setDefaultRouter(Ice.RouterPrx)">
+            <summary>
+            Set a default router for this communicator.
+            All newly
+            created proxies will use this default router. To disable the
+            default router, null can be used. Note that this
+            operation has no effect on existing proxies.
+            
+            You can also set a router for an individual proxy
+            by calling the operation ice_router on the proxy.
+            
+            </summary>
+            <param name="rtr">The default router to use for this communicator.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Communicator.getDefaultLocator">
+            <summary>
+            Get the default locator this communicator.
+            </summary>
+            <returns>The default locator for this communicator.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.setDefaultLocator(Ice.LocatorPrx)">
+            <summary>
+            Set a default Ice locator for this communicator.
+            All newly
+            created proxy and object adapters will use this default
+            locator. To disable the default locator, null can be used.
+            Note that this operation has no effect on existing proxies or
+            object adapters.
+            
+             You can also set a locator for an individual proxy
+            by calling the operation ice_locator on the proxy, or for an
+            object adapter by calling the operation ObjectAdapter.setLocator
+            on the object adapter.
+            
+            </summary>
+            <param name="loc">The default locator to use for this communicator.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Communicator.getPluginManager">
+            <summary>
+            Get the plug-in manager for this communicator.
+            </summary>
+            <returns>This communicator's plug-in manager.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.flushBatchRequests">
+            <summary>
+            Flush any pending batch requests for this communicator.
+            This means all batch requests invoked on fixed proxies
+            for all connections associated with the communicator.
+            Any errors that occur while flushing a connection are ignored.
+            </summary>
+        </member>
+        <member name="M:Ice.Communicator.createAdmin(Ice.ObjectAdapter,Ice.Identity)">
+            <summary>
+            Add the Admin object with all its facets to the provided object adapter.
+            If Ice.Admin.ServerId is set and the provided object adapter has a Locator,
+            createAdmin registers the Admin's Process facet with the Locator's LocatorRegistry.
+            
+            createAdmin call only be called once; subsequent calls raise InitializationException.
+            
+            </summary>
+            <param name="adminAdapter">The object adapter used to host the Admin object; if null and
+            Ice.Admin.Endpoints is set, create, activate and use the Ice.Admin object adapter.
+            
+            </param>
+            <param name="adminId">The identity of the Admin object.
+            
+            </param>
+            <returns>A proxy to the main ("") facet of the Admin object. Never returns a null proxy.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.getAdmin">
+            <summary>
+            Get a proxy to the main facet of the Admin object.
+            getAdmin also creates the Admin object and creates and activates the Ice.Admin object
+            adapter to host this Admin object if Ice.Admin.Enpoints is set. The identity of the Admin
+            object created by getAdmin is /admin, or /admin
+            when Ice.Admin.InstanceName is not set.
+            
+            If Ice.Admin.DelayCreation is 0 or not set, getAdmin is called by the communicator
+            initialization, after initialization of all plugins.
+            
+            </summary>
+            <returns>A proxy to the main ("") facet of the Admin object, or a null proxy if no
+            Admin object is configured.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Communicator.addAdminFacet(Ice.Object,System.String)">
+            <summary>
+            Add a new facet to the Admin object.
+            Adding a servant with a facet that is already registered
+            throws AlreadyRegisteredException.
+            
+            </summary>
+            <param name="servant">The servant that implements the new Admin facet.
+            </param>
+            <param name="facet">The name of the new Admin facet.</param>
+        </member>
+        <member name="M:Ice.Communicator.removeAdminFacet(System.String)">
+            <summary>
+            Remove the following facet to the Admin object.
+            Removing a facet that was not previously registered throws
+            NotRegisteredException.
+            
+            </summary>
+            <param name="facet">The name of the Admin facet.
+            </param>
+            <returns>The servant associated with this Admin facet.</returns>
+        </member>
+        <member name="M:Ice.Communicator.findAdminFacet(System.String)">
+            <summary>
+            Returns a facet of the Admin object.
+            </summary>
+            <param name="facet">The name of the Admin facet.
+            </param>
+            <returns>The servant associated with this Admin facet, or
+            null if no facet is registered with the given name.</returns>
+        </member>
+        <member name="M:Ice.Communicator.findAllAdminFacets">
+            <summary>
+            Returns a map of all facets of the Admin object.
+            </summary>
+            <returns>A collection containing all the facet names and
+            servants of the Admin object.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Connection.close(System.Boolean)">
+            <summary>
+            Close a connection, either gracefully or forcefully.
+            If a
+            connection is closed forcefully, it closes immediately, without
+            sending the relevant close connection protocol messages to the
+            peer and waiting for the peer to acknowledge these protocol
+            messages.
+            
+            </summary>
+            <param name="force">If true, close forcefully. Otherwise the
+            connection is closed gracefully.</param>
+        </member>
+        <member name="M:Ice.Connection.createProxy(Ice.Identity)">
+            <summary>
+            Create a special proxy that always uses this connection.
+            This
+            can be used for callbacks from a server to a client if the
+            server cannot directly establish a connection to the client,
+            for example because of firewalls. In this case, the server
+            would create a proxy using an already established connection
+            from the client.
+            
+            </summary>
+            <param name="id">The identity for which a proxy is to be created.
+            
+            </param>
+            <returns>A proxy that matches the given identity and uses this
+            connection.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Connection.setAdapter(Ice.ObjectAdapter)">
+            <summary>
+            Explicitly set an object adapter that dispatches requests that
+            are received over this connection.
+            A client can invoke an
+            operation on a server using a proxy, and then set an object
+            adapter for the outgoing connection that is used by the proxy
+            in order to receive callbacks. This is useful if the server
+            cannot establish a connection back to the client, for example
+            because of firewalls.
+            
+            </summary>
+            <param name="adapter">The object adapter that should be used by this
+            connection to dispatch requests. The object adapter must be
+            activated. When the object adapter is deactivated, it is
+            automatically removed from the connection.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Connection.getAdapter">
+            <summary>
+            Get the object adapter that dispatches requests for this
+            connection.
+            </summary>
+            <returns>The object adapter that dispatches requests for the
+            connection, or null if no adapter is set.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Connection.getEndpoint">
+            <summary>
+            Get the endpoint from which the connection was created.
+            </summary>
+            <returns>The endpoint from which the connection was created.</returns>
+        </member>
+        <member name="M:Ice.Connection.flushBatchRequests">
+            <summary>
+            Flush any pending batch requests for this connection.
+            This means all batch requests invoked on fixed proxies
+            associated with the connection.
+            </summary>
+        </member>
+        <member name="M:Ice.Connection.setCallback(Ice.ConnectionCallback)">
+            <summary>
+            Set callback on the connection.
+            The callback is called by the
+            connection when it's closed. The callback is called from the
+            Ice thread pool associated with the connection.
+            
+            </summary>
+            <param name="callback">The connection callback object.</param>
+        </member>
+        <member name="M:Ice.Connection.setACM(Ice.Optional{System.Int32},Ice.Optional{Ice.ACMClose},Ice.Optional{Ice.ACMHeartbeat})">
+            <summary>
+            Set the active connection management parameters.
+            </summary>
+            <param name="timeout">The timeout value in milliseconds.
+            
+            </param>
+            <param name="close">The close condition
+            
+            </param>
+            <param name="heartbeat">The hertbeat condition</param>
+        </member>
+        <member name="M:Ice.Connection.getACM">
+            <summary>
+            Get the ACM parameters.
+            </summary>
+            <returns>The ACM parameters.</returns>
+        </member>
+        <member name="M:Ice.Connection.type">
+            <summary>
+            Return the connection type.
+            This corresponds to the endpoint
+            type, i.e., "tcp", "udp", etc.
+            
+            </summary>
+            <returns>The type of the connection.</returns>
+        </member>
+        <member name="M:Ice.Connection.timeout">
+            <summary>
+            Get the timeout for the connection.
+            </summary>
+            <returns>The connection's timeout.</returns>
+        </member>
+        <member name="M:Ice.Connection.ice_toString_">
+            <summary>
+            Return a description of the connection as human readable text,
+            suitable for logging or error messages.
+            </summary>
+            <returns>The description of the connection as human readable
+            text.</returns>
+        </member>
+        <member name="M:Ice.Connection.getInfo">
+            <summary>
+            Returns the connection information.
+            </summary>
+            <returns>The connection information.</returns>
+        </member>
+        <member name="M:Ice.Connection.setBufferSize(System.Int32,System.Int32)">
+            <summary>
+            Set the connectiion buffer receive/send size.
+            </summary>
+            <param name="rcvSize">The connection receive buffer size.
+            </param>
+            <param name="sndSize">The connection send buffer size.</param>
+        </member>
+        <member name="T:Ice.DispatchInterceptor">
+            <summary>
+            Base class that allows a server intercept incoming requests.
+            The application must derive a concrete class from DispatchInterceptor
+            that implements the DispatchInterceptor.dispatch operation. An instance of this derived
+            class can be registered with an object adapter like any other servant.
+            A dispatch interceptor is useful particularly to automatically retry requests
+            that have failed due to a recoverable error condition.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectImpl">
+            <summary>
+            Base class for all Slice classes.
+            </summary>
+        </member>
+        <member name="T:Ice.Object">
+            <summary>
+            the base interface for servants.
+            </summary>
+        </member>
+        <member name="M:Ice.Object.ice_isA(System.String)">
+             <summary>
+             Tests whether this object supports a specific Slice interface.
+             </summary>
+            
+             <param name="s">The type ID of the Slice interface to test against.</param>
+             <returns>True if this object has the interface
+             specified by s or derives from the interface specified by s.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_isA(System.String,Ice.Current)">
+             <summary>
+             Tests whether this object supports a specific Slice interface.
+             </summary>
+            
+             <param name="s">The type ID of the Slice interface to test against.</param>
+             <param name="current">The Current object for the invocation.</param>
+             <returns>True if this object has the interface
+             specified by s or derives from the interface specified by s.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_ping">
+            <summary>
+            Tests whether this object can be reached.
+            </summary>
+        </member>
+        <member name="M:Ice.Object.ice_ping(Ice.Current)">
+            <summary>
+            Tests whether this object can be reached.
+            </summary>
+            <param name="current">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.Object.ice_ids">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by this object.
+            </summary>
+            <returns>The Slice type IDs of the interfaces supported by this object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_ids(Ice.Current)">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by this object.
+            </summary>
+            <param name="current">The Current object for the invocation.</param>
+            <returns>The Slice type IDs of the interfaces supported by this object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_id">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by this object.
+            </summary>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_id(Ice.Current)">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by this object.
+            </summary>
+            <param name="current">The Current object for the invocation.</param>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_preMarshal">
+            <summary>
+            The Ice run time invokes this method prior to marshaling an object's data members. This allows a subclass
+            to override this method in order to validate its data members.
+            </summary>
+        </member>
+        <member name="M:Ice.Object.ice_postUnmarshal">
+            <summary>
+            This Ice run time invokes this method vafter unmarshaling an object's data members. This allows a
+            subclass to override this method in order to perform additional initialization.
+            </summary>
+        </member>
+        <member name="M:Ice.Object.ice_dispatch(Ice.Request,Ice.DispatchInterceptorAsyncCallback)">
+            <summary>
+            Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation
+            to a servant (or to another interceptor).
+            </summary>
+            <param name="request">The details of the invocation.</param>
+            <param name="cb">The callback object for asynchchronous dispatch. For synchronous dispatch,
+            the callback object must be null.</param>
+            <returns>The dispatch status for the operation.</returns>
+        </member>
+        <member name="M:Ice.Object.ice_dispatch(Ice.Request)">
+            <summary>
+            Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation
+            to a servant (or to another interceptor).
+            </summary>
+            <param name="request">The details of the invocation.</param>
+            <returns>The dispatch status for the operation.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.#ctor">
+            <summary>
+            Instantiates an Ice object.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectImpl.Clone">
+            <summary>
+            Returns a copy of the object. The cloned object contains field-for-field copies
+            of the state.
+            </summary>
+            <returns>The cloned object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_isA(System.String)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="s">The type ID of the Slice interface to test against.</param>
+            <returns>The return value is true if s is ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_isA(System.String,Ice.Current)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="s">The type ID of the Slice interface to test against.</param>
+            <param name="current">The Current object for the invocation.</param>
+            <returns>The return value is true if s is ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_ping">
+            <summary>
+            Tests whether this object can be reached.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_ping(Ice.Current)">
+            <summary>
+            Tests whether this object can be reached.
+            <param name="current">The Current object for the invocation.</param>
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_ids">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by this object.
+            </summary>
+            <returns>An array whose only element is ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_ids(Ice.Current)">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by this object.
+            </summary>
+            <param name="current">The Current object for the invocation.</param>
+            <returns>An array whose only element is ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_id">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by this object.
+            </summary>
+            <returns>The return value is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_id(Ice.Current)">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by this object.
+            </summary>
+            <param name="current">The Current object for the invocation.</param>
+            <returns>The return value is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_staticId">
+            <summary>
+            Returns the Slice type ID of the interface supported by this object.
+            </summary>
+            <returns>The return value is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_preMarshal">
+            <summary>
+            The Ice run time invokes this method prior to marshaling an object's data members. This allows a subclass
+            to override this method in order to validate its data members.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_postUnmarshal">
+            <summary>
+            This Ice run time invokes this method vafter unmarshaling an object's data members. This allows a
+            subclass to override this method in order to perform additional initialization.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_dispatch(Ice.Request,Ice.DispatchInterceptorAsyncCallback)">
+            <summary>
+            Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation
+            to a servant (or to another interceptor).
+            </summary>
+            <param name="request">The details of the invocation.</param>
+            <param name="cb">The callback object for asynchchronous dispatch. For synchronous dispatch, the
+            callback object must be null.</param>
+            <returns>The dispatch status for the operation.</returns>
+        </member>
+        <member name="M:Ice.ObjectImpl.ice_dispatch(Ice.Request)">
+            <summary>
+            Dispatches an invocation to a servant. This method is used by dispatch interceptors to forward an invocation
+            to a servant (or to another interceptor).
+            </summary>
+            <param name="request">The details of the invocation.</param>
+            <returns>The dispatch status for the operation.</returns>
+        </member>
+        <member name="M:Ice.DispatchInterceptor.dispatch(Ice.Request)">
+            <summary>
+            Called by the Ice run time to dispatch an incoming request. The implementation
+            of <code>dispatch</code> must dispatch the request to the actual servant.
+            </summary>
+            <param name="request">The details of the incoming request.</param>
+            <returns>For synchronous dispatch, the return value must be whatever is
+            returned ice_dispatch. For asynchronous dispatch, the return
+            value must be DispatchAsync.</returns>
+        </member>
+        <member name="M:Ice.Endpoint.ice_toString_">
+            <summary>
+            Return a string representation of the endpoint.
+            </summary>
+            <returns>The string representation of the endpoint.</returns>
+        </member>
+        <member name="M:Ice.Endpoint.getInfo">
+            <summary>
+            Returns the endpoint information.
+            </summary>
+            <returns>The endpoint information class.</returns>
+        </member>
+        <member name="T:Ice.Exception">
+            <summary>
+            Base class for Ice exceptions.
+            </summary>
+        </member>
+        <member name="M:Ice.Exception.Clone">
+            <summary>
+            Creates and returns a copy of this exception.
+            </summary>
+            <returns>A copy of this exception.</returns>
+        </member>
+        <member name="M:Ice.Exception.#ctor">
+            <summary>
+            Creates a default-initialized exception.
+            </summary>
+        </member>
+        <member name="M:Ice.Exception.#ctor(System.Exception)">
+            <summary>
+            Creates a default-initialized exception and sets the InnerException
+            property to the passed exception.
+            </summary>
+            <param name="ex">The inner exception.</param>
+        </member>
+        <member name="M:Ice.Exception.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the exception with serialized data.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="M:Ice.Exception.ice_name">
+            <summary>
+            Returns the name of this exception.
+            </summary>
+            <returns>The name of this exception.</returns>
+        </member>
+        <member name="M:Ice.Exception.ToString">
+            <summary>
+            Returns a string representation of this exception, including
+            any inner exceptions.
+            </summary>
+            <returns>The string representation of this exception.</returns>
+        </member>
+        <member name="T:Ice.LocalException">
+            <summary>
+            Base class for local exceptions.
+            </summary>
+        </member>
+        <member name="M:Ice.LocalException.#ctor">
+            <summary>
+            Creates a default-initialized local exception.
+            </summary>
+        </member>
+        <member name="M:Ice.LocalException.#ctor(System.Exception)">
+            <summary>
+            Creates a default-initialized local exception and sets the InnerException
+            property to the passed exception.
+            </summary>
+            <param name="ex">The inner exception.</param>
+        </member>
+        <member name="M:Ice.LocalException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the exception with serialized data.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="T:Ice.SystemException">
+            <summary>
+            Base class for Ice run-time exceptions.
+            </summary>
+        </member>
+        <member name="M:Ice.SystemException.#ctor">
+            <summary>
+            Creates a default-initialized run-time exception.
+            </summary>
+        </member>
+        <member name="M:Ice.SystemException.#ctor(System.Exception)">
+            <summary>
+            Creates a default-initialized run-time exception and sets the InnerException
+            property to the passed exception.
+            </summary>
+            <param name="ex">The inner exception.</param>
+        </member>
+        <member name="M:Ice.SystemException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the exception with serialized data.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="T:Ice.UserException">
+            <summary>
+            Base class for Slice user exceptions.
+            </summary>
+        </member>
+        <member name="M:Ice.UserException.#ctor">
+            <summary>
+            Creates a default-initialized user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.UserException.#ctor(System.Exception)">
+            <summary>
+            Creates a default-initialized user exception and sets the InnerException
+            property to the passed exception.
+            </summary>
+            <param name="ex">The inner exception.</param>
+        </member>
+        <member name="M:Ice.UserException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the exception with serialized data.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="T:Ice.FormatType">
+            <summary>
+            This enumeration describes the possible formats for classes and exceptions.
+            </summary>
+        </member>
+        <member name="M:Ice.ImplicitContext.getContext">
+            <summary>
+            Get a copy of the underlying context.
+            </summary>
+            <returns>A copy of the underlying context.</returns>
+        </member>
+        <member name="M:Ice.ImplicitContext.setContext(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the underlying context.
+            </summary>
+            <param name="newContext">The new context.</param>
+        </member>
+        <member name="M:Ice.ImplicitContext.containsKey(System.String)">
+            <summary>
+            Check if this key has an associated value in the underlying context.
+            </summary>
+            <param name="key">The key.
+            
+            </param>
+            <returns>True if the key has an associated value, False otherwise.</returns>
+        </member>
+        <member name="M:Ice.ImplicitContext.get(System.String)">
+            <summary>
+            Get the value associated with the given key in the underlying context.
+            Returns an empty string if no value is associated with the key.
+            containsKey allows you to distinguish between an empty-string value and 
+            no value at all.
+            
+            </summary>
+            <param name="key">The key.
+            
+            </param>
+            <returns>The value associated with the key.</returns>
+        </member>
+        <member name="M:Ice.ImplicitContext.put(System.String,System.String)">
+            <summary>
+            Create or update a key/value entry in the underlying context.
+            </summary>
+            <param name="key">The key.
+            
+            </param>
+            <param name="value">The value.
+            
+            </param>
+            <returns>The previous value associated with the key, if any.</returns>
+        </member>
+        <member name="M:Ice.ImplicitContext.remove(System.String)">
+            <summary>
+            Remove the entry for the given key in the underlying context.
+            </summary>
+            <param name="key">The key.
+            
+            </param>
+            <returns>The value associated with the key, if any.</returns>
+        </member>
+        <member name="T:Ice.Request">
+            <summary>
+            Interface for incoming requests.
+            </summary>
+        </member>
+        <member name="M:Ice.Request.getCurrent">
+            <summary>
+            Returns the {@link Current} object for this the request.
+            </summary>
+            <returns>The Current object for this request.</returns>
+        </member>
+        <member name="T:Ice.AMD_Object_ice_invoke">
+            <summary>
+            Callback interface for Blobject AMD servants.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_Object_ice_invoke.ice_response(System.Boolean,System.Byte[])">
+            <summary>
+            Indicates to the Ice run time that an operation
+            completed.
+            </summary>
+            <param name="ok">True indicates that the operation
+            completed successfully; false indicates that the
+            operation raised a user exception.</param>
+            <param name="outEncaps">The encoded out-parameters for the operation or,
+            if ok is false, the encoded user exception.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.ObserverUpdater.updateConnectionObservers">
+            <summary>
+            Update connection observers associated with each of the Ice
+            connection from the communicator and its object adapters.
+            When called, this method goes through all the connections and
+            for each connection CommunicatorObserver.getConnectionObserver
+            is called. The implementation of getConnectionObserver has the
+            possibility to return an updated observer if necessary.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.ObserverUpdater.updateThreadObservers">
+            <summary>
+            Update thread observers associated with each of the Ice thread
+            from the communicator and its object adapters.
+            When called, this method goes through all the threads and for
+            each thread CommunicatorObserver.getThreadObserver is
+            called. The implementation of getThreadObserver has the
+            possibility to return an updated observer if necessary.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.Observer.attach">
+            <summary>
+            This method is called when the instrumented object is created
+            or when the observer is attached to an existing object.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.Observer.detach">
+            <summary>
+            This method is called when the instrumented object is destroyed
+            and as a result the observer detached from the object.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.Observer.failed(System.String)">
+            <summary>
+            Notification of a failure.
+            </summary>
+            <param name="exceptionName">The name of the exception.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.ConnectionObserver.sentBytes(System.Int32)">
+            <summary>
+            Notification of sent bytes over the connection.
+            </summary>
+            <param name="num">The number of bytes sent.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.ConnectionObserver.receivedBytes(System.Int32)">
+            <summary>
+            Notification of received bytes over the connection.
+            </summary>
+            <param name="num">The number of bytes received.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.DispatchObserver.userException">
+            <summary>
+            Notification of a user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.DispatchObserver.reply(System.Int32)">
+            <summary>
+            Reply notification.
+            </summary>
+            <param name="size">The size of the reply.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.ChildInvocationObserver.reply(System.Int32)">
+            <summary>
+            Reply notification.
+            </summary>
+            <param name="size">The size of the reply.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.InvocationObserver.retried">
+            <summary>
+            Notification of the invocation being retried.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.InvocationObserver.userException">
+            <summary>
+            Notification of a user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.Instrumentation.InvocationObserver.getRemoteObserver(Ice.ConnectionInfo,Ice.Endpoint,System.Int32,System.Int32)">
+            <summary>
+            Get a remote observer for this invocation.
+            </summary>
+            <param name="con">The connection information.
+            
+            </param>
+            <param name="endpt">The connection endpoint.
+            
+            </param>
+            <param name="requestId">The ID of the invocation.
+            
+            </param>
+            <param name="size">The size of the invocation.
+            
+            </param>
+            <returns>The observer to instrument the remote invocation.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.InvocationObserver.getCollocatedObserver(Ice.ObjectAdapter,System.Int32,System.Int32)">
+            <summary>
+            Get a collocated observer for this invocation.
+            </summary>
+            <param name="adapter">The object adapter hosting the collocated Ice object.
+            
+            </param>
+            <param name="requestId">The ID of the invocation.
+            
+            </param>
+            <param name="size">The size of the invocation.
+            
+            </param>
+            <returns>The observer to instrument the collocated invocation.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.ThreadObserver.stateChanged(Ice.Instrumentation.ThreadState,Ice.Instrumentation.ThreadState)">
+            <summary>
+            Notification of thread state change.
+            </summary>
+            <param name="oldState">The previous thread state.
+            
+            </param>
+            <param name="newState">The new thread state.</param>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getConnectionEstablishmentObserver(Ice.Endpoint,System.String)">
+            <summary>
+            This method should return an observer for the given endpoint
+            information and connector.
+            The Ice run-time calls this method
+            for each connection establishment attempt.
+            
+            </summary>
+            <param name="endpt">The endpoint.
+            
+            </param>
+            <param name="connector">The description of the connector. For IP
+            transports, this is typically the IP address to connect to.
+            
+            </param>
+            <returns>The observer to instrument the connection establishment.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getEndpointLookupObserver(Ice.Endpoint)">
+            <summary>
+            This method should return an observer for the given endpoint
+            information.
+            The Ice run-time calls this method to resolve an
+            endpoint and obtain the list of connectors.
+            
+            For IP endpoints, this typically involves doing a DNS lookup to
+            obtain the IP addresses associated with the DNS name.
+            
+            </summary>
+            <param name="endpt">The endpoint.
+            
+            </param>
+            <returns>The observer to instrument the endpoint lookup.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getConnectionObserver(Ice.ConnectionInfo,Ice.Endpoint,Ice.Instrumentation.ConnectionState,Ice.Instrumentation.ConnectionObserver)">
+            <summary>
+            This method should return a connection observer for the given
+            connection.
+            The Ice run-time calls this method for each new
+            connection and for all the Ice communicator connections when
+            ObserverUpdater.updateConnectionObservers is called.
+            
+            </summary>
+            <param name="c">The connection information.
+            
+            </param>
+            <param name="e">The connection endpoint.
+            
+            </param>
+            <param name="s">The state of the connection.
+            
+            </param>
+            <param name="o">The old connection observer if one is already set or a
+            null reference otherwise.
+            
+            </param>
+            <returns>The connection observer to instrument the connection.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getThreadObserver(System.String,System.String,Ice.Instrumentation.ThreadState,Ice.Instrumentation.ThreadObserver)">
+            <summary>
+            This method should return a thread observer for the given
+            thread.
+            The Ice run-time calls this method for each new thread
+            and for all the Ice communicator threads when
+            ObserverUpdater.updateThreadObservers is called.
+            
+            </summary>
+            <param name="parent">The parent of the thread.
+            
+            </param>
+            <param name="id">The ID of the thread to observe.
+            
+            </param>
+            <param name="s">The state of the thread.
+            
+            </param>
+            <param name="o">The old thread observer if one is already set or a
+            null reference otherwise.
+            
+            </param>
+            <returns>The thread observer to instrument the thread.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getInvocationObserver(Ice.ObjectPrx,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            This method should return an invocation observer for the given
+            invocation.
+            The Ice run-time calls this method for each new
+            invocation on a proxy.
+            
+            </summary>
+            <param name="prx">The proxy used for the invocation.
+            
+            </param>
+            <param name="operation">The name of the invocation.
+            
+            </param>
+            <param name="ctx">The context specified by the user.
+            
+            </param>
+            <returns>The invocation observer to instrument the invocation.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.getDispatchObserver(Ice.Current,System.Int32)">
+            <summary>
+            This method should return a dispatch observer for the given
+            dispatch.
+            The Ice run-time calls this method each time it
+            receives an incoming invocation to be dispatched for an Ice
+            object.
+            
+            </summary>
+            <param name="c">The current object as provided to the Ice servant
+            dispatching the invocation.
+            
+            </param>
+            <param name="size">The size of the dispatch.
+            
+            </param>
+            <returns>The dispatch observer to instrument the dispatch.</returns>
+        </member>
+        <member name="M:Ice.Instrumentation.CommunicatorObserver.setObserverUpdater(Ice.Instrumentation.ObserverUpdater)">
+            <summary>
+            The Ice run-time calls this method when the communicator is
+            initialized.
+            The add-in implementing this interface can use
+            this object to get the Ice run-time to re-obtain observers for
+            observed objects.
+            
+            </summary>
+            <param name="updater">The observer updater object.</param>
+        </member>
+        <member name="M:Ice.EndpointInfo.type">
+            <summary>
+            Returns the type of the endpoint.
+            </summary>
+        </member>
+        <member name="M:Ice.EndpointInfo.datagram">
+            <summary>
+            Returns true if this endpoint is a datagram endpoint.
+            </summary>
+        </member>
+        <member name="M:Ice.EndpointInfo.secure">
+            <summary>
+            Returns true if this endpoint is a secure endpoint.
+            </summary>
+        </member>
+        <member name="T:Ice.LoggerAdminOperations_">
+            <summary>
+            The interface of the admin object that allows an Ice application the attach its
+            RemoteLogger to the Logger of this admin object's Ice communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.LoggerAdminOperations_.attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32,Ice.Current)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <exception name="RemoteLoggerAlreadyAttachedException">Raised if this remote logger is already
+            attached to this admin object.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminOperations_.detachRemoteLogger(Ice.RemoteLoggerPrx,Ice.Current)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <returns>True if the provided remote logger proxy was detached, and false otherwise.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminOperations_.getLog(Ice.LogMessageType[],System.String[],System.Int32,System.String@,Ice.Current)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="prefix">The prefix of the associated local Logger.
+            
+            </param>
+            <returns>The Log messages.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LoggerAdminOperationsNC_">
+            <summary>
+            The interface of the admin object that allows an Ice application the attach its
+            RemoteLogger to the Logger of this admin object's Ice communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.LoggerAdminOperationsNC_.attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <exception name="RemoteLoggerAlreadyAttachedException">Raised if this remote logger is already
+            attached to this admin object.</exception>
+        </member>
+        <member name="M:Ice.LoggerAdminOperationsNC_.detachRemoteLogger(Ice.RemoteLoggerPrx)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <returns>True if the provided remote logger proxy was detached, and false otherwise.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminOperationsNC_.getLog(Ice.LogMessageType[],System.String[],System.Int32,System.String@)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="prefix">The prefix of the associated local Logger.
+            
+            </param>
+            <returns>The Log messages.</returns>
+        </member>
+        <member name="M:Ice.Logger.print(System.String)">
+            <summary>
+            Print a message.
+            The message is printed literally, without
+            any decorations such as executable name or time stamp.
+            </summary>
+        </member>
+        <member name="M:Ice.Logger.trace(System.String,System.String)">
+            <summary>
+            Log a trace message.
+            </summary>
+            <param name="category">The trace category.
+            
+            </param>
+            <param name="message">The trace message to log.</param>
+        </member>
+        <member name="M:Ice.Logger.warning(System.String)">
+            <summary>
+            Log a warning message.
+            </summary>
+            <param name="message">The warning message to log.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Logger.error(System.String)">
+            <summary>
+            Log an error message.
+            </summary>
+            <param name="message">The error message to log.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Logger.getPrefix">
+            <summary>
+            Returns this logger's prefix.
+            </summary>
+            <returns>The prefix.</returns>
+        </member>
+        <member name="M:Ice.Logger.cloneWithPrefix(System.String)">
+            <summary>
+            Returns a clone of the logger with a new prefix.
+            </summary>
+            <param name="prefix">The new prefix for the logger.</param>
+        </member>
+        <member name="T:Ice.LoggerPlugin">
+            <summary>
+            Class to support custom loggers. Applications using a custom logger
+            instantiate a LoggerPlugin with a custom logger and
+            return the instance from their PluginFactory implementation.
+            </summary>
+        </member>
+        <member name="M:Ice.Plugin.initialize">
+            <summary>
+            Perform any necessary initialization steps.
+            </summary>
+        </member>
+        <member name="M:Ice.Plugin.destroy">
+            <summary>
+            Called when the communicator is being destroyed.
+            </summary>
+        </member>
+        <member name="M:Ice.LoggerPlugin.#ctor(Ice.Communicator,Ice.Logger)">
+            <summary>
+            Installs a custom logger for a communicator.
+            </summary>
+            <param name="communicator">The communicator using the custom logger.</param>
+            <param name="logger">The custom logger for the communicator.</param>
+        </member>
+        <member name="M:Ice.LoggerPlugin.initialize">
+            <summary>
+            Called by the Ice run time during communicator initialization. The derived class
+            can override this method to perform any initialization that might be required
+            by a custom logger.
+            </summary>
+        </member>
+        <member name="M:Ice.LoggerPlugin.destroy">
+            <summary>
+            Called by the Ice run time when the communicator is destroyed. The derived class
+            can override this method to perform any finalization that might be required
+            by a custom logger.
+            </summary>
+        </member>
+        <member name="T:IceMX.MetricsAdminOperations_">
+            <summary>
+            The metrics administrative facet interface.
+            This interface allows
+            remote administrative clients to access metrics of an application
+            that enabled the Ice administrative facility and configured some
+            metrics views.
+            </summary>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.getMetricsViewNames(System.String[]@,Ice.Current)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="disabledViews">The names of the disabled views.
+            
+            </param>
+            <returns>The name of the enabled views.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.enableMetricsView(System.String,Ice.Current)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.disableMetricsView(System.String,Ice.Current)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.getMetricsView(System.String,System.Int64@,Ice.Current)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            returns a dictionnary of metric maps for each metrics class
+            configured with the view. The timestamp allows the client to
+            compute averages which are not dependent of the invocation
+            latency for this operation.
+            
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="timestamp">The local time of the process when the metrics
+            object were retrieved.
+            
+            </param>
+            <returns>The metrics view data.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.getMapMetricsFailures(System.String,System.String,Ice.Current)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <returns>The metrics failures associated with the map.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperations_.getMetricsFailures(System.String,System.String,System.String,Ice.Current)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <returns>The metrics failures associated with the metrics.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:IceMX.MetricsAdminOperationsNC_">
+            <summary>
+            The metrics administrative facet interface.
+            This interface allows
+            remote administrative clients to access metrics of an application
+            that enabled the Ice administrative facility and configured some
+            metrics views.
+            </summary>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.getMetricsViewNames(System.String[]@)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="disabledViews">The names of the disabled views.
+            
+            </param>
+            <returns>The name of the enabled views.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.enableMetricsView(System.String)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.disableMetricsView(System.String)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.getMetricsView(System.String,System.Int64@)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            returns a dictionnary of metric maps for each metrics class
+            configured with the view. The timestamp allows the client to
+            compute averages which are not dependent of the invocation
+            latency for this operation.
+            
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="timestamp">The local time of the process when the metrics
+            object were retrieved.
+            
+            </param>
+            <returns>The metrics view data.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.getMapMetricsFailures(System.String,System.String)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <returns>The metrics failures associated with the map.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminOperationsNC_.getMetricsFailures(System.String,System.String,System.String)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <returns>The metrics failures associated with the metrics.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="T:Ice.DispatchStatus">
+            <summary>
+            Indicates the status of operation dispatch.
+            </summary>
+        </member>
+        <member name="F:Ice.DispatchStatus.DispatchOK">
+            <summary>
+            Indicates that an operation was dispatched synchronously and successfully.
+            </summary>
+        </member>
+        <member name="F:Ice.DispatchStatus.DispatchUserException">
+            <summary>
+            Indicates that an operation was dispatched synchronously and raised a user exception.
+            </summary>
+        </member>
+        <member name="F:Ice.DispatchStatus.DispatchAsync">
+            <summary>
+            Indicates that an operation was dispatched asynchronously.
+            </summary>
+        </member>
+        <member name="T:Ice.Blobject">
+            <summary>
+            Base class for dynamic dispatch servants. A server application
+            derives a concrete servant class from Blobject that
+            implements the Blobject.ice_invoke method.
+            </summary>
+        </member>
+        <member name="M:Ice.Blobject.ice_invoke(System.Byte[],System.Byte[]@,Ice.Current)">
+            <summary>
+            Dispatch an incoming request.
+            </summary>
+            <param name="inParams">The encoded in-parameters for the operation.</param>
+            <param name="outParams">The encoded out-paramaters and return value
+            for the operation. The return value follows any out-parameters.</param>
+            <param name="current">The Current object to pass to the operation.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outParams
+            must contain the encoded user exception. If the operation raises an
+            Ice run-time exception, it must throw it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.getName">
+            <summary>
+            Get the name of this object adapter.
+            </summary>
+            <returns>This object adapter's name.</returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.getCommunicator">
+            <summary>
+            Get the communicator this object adapter belongs to.
+            </summary>
+            <returns>This object adapter's communicator.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.activate">
+            <summary>
+            Activate all endpoints that belong to this object adapter.
+            After activation, the object adapter can dispatch requests
+            received through its endpoints.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.hold">
+            <summary>
+            Temporarily hold receiving and dispatching requests.
+            The object
+            adapter can be reactivated with the activate operation.
+            
+             Holding is not immediate, i.e., after hold
+            returns, the object adapter might still be active for some
+            time. You can use waitForHold to wait until holding is
+            complete.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.waitForHold">
+            <summary>
+            Wait until the object adapter holds requests.
+            Calling hold
+            initiates holding of requests, and waitForHold only returns
+            when holding of requests has been completed.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.deactivate">
+            <summary>
+            Deactivate all endpoints that belong to this object adapter.
+            After deactivation, the object adapter stops receiving
+            requests through its endpoints. Object adapters that have been
+            deactivated must not be reactivated again, and cannot be used
+            otherwise. Attempts to use a deactivated object adapter raise
+            ObjectAdapterDeactivatedException; however, attempts to
+            deactivate an already deactivated object adapter are
+            ignored and do nothing. Once deactivated, it is possible to
+            destroy the adapter to clean up resources and then create and
+            activate a new adapter with the same name.
+            
+             After deactivate returns, no new requests
+            are processed by the object adapter. However, requests that
+            have been started before deactivate was called might
+            still be active. You can use waitForDeactivate to wait
+            for the completion of all requests for this object adapter.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.waitForDeactivate">
+            <summary>
+            Wait until the object adapter has deactivated.
+            Calling
+            deactivate initiates object adapter deactivation, and
+            waitForDeactivate only returns when deactivation has
+            been completed.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.isDeactivated">
+            <summary>
+            Check whether object adapter has been deactivated.
+            </summary>
+            <returns>Whether adapter has been deactivated.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.destroy">
+            <summary>
+            Destroys the object adapter and cleans up all resources held by
+            the object adapter.
+            If the object adapter has not yet been
+            deactivated, destroy implicitly initiates the deactivation
+            and waits for it to finish. Subsequent calls to destroy are
+            ignored. Once destroy has returned, it is possible to create
+            another object adapter with the same name.
+            
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.add(Ice.Object,Ice.Identity)">
+            <summary>
+            Add a servant to this object adapter's Active Servant Map.
+            Note
+            that one servant can implement several Ice objects by registering
+            the servant with multiple identities. Adding a servant with an
+            identity that is in the map already throws AlreadyRegisteredException.
+            
+            </summary>
+            <param name="servant">The servant to add.
+            
+            </param>
+            <param name="id">The identity of the Ice object that is implemented by
+            the servant.
+            
+            </param>
+            <returns>A proxy that matches the given identity and this object
+            adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.addFacet(Ice.Object,Ice.Identity,System.String)">
+            <summary>
+            Like add, but with a facet.
+            Calling add(servant, id)
+            is equivalent to calling addFacet with an empty facet.
+            
+            </summary>
+            <param name="servant">The servant to add.
+            
+            </param>
+            <param name="id">The identity of the Ice object that is implemented by
+            the servant.
+            
+            </param>
+            <param name="facet">The facet. An empty facet means the default facet.
+            
+            </param>
+            <returns>A proxy that matches the given identity, facet, and
+            this object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.addWithUUID(Ice.Object)">
+            <summary>
+            Add a servant to this object adapter's Active Servant Map,
+            using an automatically generated UUID as its identity.
+            Note that
+            the generated UUID identity can be accessed using the proxy's
+            ice_getIdentity operation.
+            
+            </summary>
+            <param name="servant">The servant to add.
+            
+            </param>
+            <returns>A proxy that matches the generated UUID identity and
+            this object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.addFacetWithUUID(Ice.Object,System.String)">
+            <summary>
+            Like addWithUUID, but with a facet.
+            Calling
+            addWithUUID(servant) is equivalent to calling
+            addFacetWithUUID with an empty facet.
+            
+            </summary>
+            <param name="servant">The servant to add.
+            
+            </param>
+            <param name="facet">The facet. An empty facet means the default
+            facet.
+            
+            </param>
+            <returns>A proxy that matches the generated UUID identity,
+            facet, and this object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.addDefaultServant(Ice.Object,System.String)">
+            <summary>
+            Add a default servant to handle requests for a specific
+            category.
+            Adding a default servant for a category for
+            which a default servant is already registered throws
+            AlreadyRegisteredException. To dispatch operation
+            calls on servants, the object adapter tries to find a servant
+            for a given Ice object identity and facet in the following
+            order:
+            
+            
+            
+            The object adapter tries to find a servant for the identity
+            and facet in the Active Servant Map.
+            
+            If no servant has been found in the Active Servant Map, the
+            object adapter tries to find a default servant for the category
+            component of the identity.
+            
+            If no servant has been found by any of the preceding steps,
+            the object adapter tries to find a default servant for an empty
+            category, regardless of the category contained in the identity.
+            
+            If no servant has been found by any of the preceding steps,
+            the object adapter gives up and the caller receives
+            ObjectNotExistException or FacetNotExistException.
+            
+            
+            
+            </summary>
+            <param name="servant">The default servant.
+            
+            </param>
+            <param name="category">The category for which the default servant is
+            registered. An empty category means it will handle all categories.
+            
+            </param>
+        </member>
+        <member name="M:Ice.ObjectAdapter.remove(Ice.Identity)">
+            <summary>
+            Remove a servant (that is, the default facet) from the object
+            adapter's Active Servant Map.
+            </summary>
+            <param name="id">The identity of the Ice object that is implemented by
+            the servant. If the servant implements multiple Ice objects,
+            remove has to be called for all those Ice objects.
+            Removing an identity that is not in the map throws
+            NotRegisteredException.
+            
+            </param>
+            <returns>The removed servant.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.removeFacet(Ice.Identity,System.String)">
+            <summary>
+            Like remove, but with a facet.
+            Calling remove(id)
+            is equivalent to calling removeFacet with an empty facet.
+            
+            </summary>
+            <param name="id">The identity of the Ice object that is implemented by
+            the servant.
+            
+            </param>
+            <param name="facet">The facet. An empty facet means the default facet.
+            
+            </param>
+            <returns>The removed servant.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.removeAllFacets(Ice.Identity)">
+            <summary>
+            Remove all facets with the given identity from the Active
+            Servant Map.
+            The operation completely removes the Ice object,
+            including its default facet. Removing an identity that
+            is not in the map throws NotRegisteredException.
+            
+            </summary>
+            <param name="id">The identity of the Ice object to be removed.
+            
+            </param>
+            <returns>A collection containing all the facet names and
+            servants of the removed Ice object.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.removeDefaultServant(System.String)">
+            <summary>
+            Remove the default servant for a specific category.
+            Attempting
+            to remove a default servant for a category that is not
+            registered throws NotRegisteredException.
+            
+            </summary>
+            <param name="category">The category of the default servant to remove.
+            
+            </param>
+            <returns>The default servant.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.find(Ice.Identity)">
+            <summary>
+            Look up a servant in this object adapter's Active Servant Map
+            by the identity of the Ice object it implements.
+            This operation only tries to look up a servant in
+            the Active Servant Map. It does not attempt to find a servant
+            by using any installed ServantLocator.
+            
+            </summary>
+            <param name="id">The identity of the Ice object for which the servant
+            should be returned.
+            
+            </param>
+            <returns>The servant that implements the Ice object with the
+            given identity, or null if no such servant has been found.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.findFacet(Ice.Identity,System.String)">
+            <summary>
+            Like find, but with a facet.
+            Calling find(id)
+            is equivalent to calling findFacet with an empty
+            facet.
+            
+            </summary>
+            <param name="id">The identity of the Ice object for which the
+            servant should be returned.
+            
+            </param>
+            <param name="facet">The facet. An empty facet means the default
+            facet.
+            
+            </param>
+            <returns>The servant that implements the Ice object with the
+            given identity and facet, or null if no such servant has been
+            found.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.findAllFacets(Ice.Identity)">
+            <summary>
+            Find all facets with the given identity in the Active Servant
+            Map.
+            </summary>
+            <param name="id">The identity of the Ice object for which the facets
+            should be returned.
+            
+            </param>
+            <returns>A collection containing all the facet names and
+            servants that have been found, or an empty map if there is no
+            facet for the given identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.findByProxy(Ice.ObjectPrx)">
+            <summary>
+            Look up a servant in this object adapter's Active Servant Map,
+            given a proxy.
+            This operation only tries to lookup a servant in
+            the Active Servant Map. It does not attempt to find a servant
+            by using any installed ServantLocator.
+            
+            </summary>
+            <param name="proxy">The proxy for which the servant should be returned.
+            
+            </param>
+            <returns>The servant that matches the proxy, or null if no such
+            servant has been found.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.addServantLocator(Ice.ServantLocator,System.String)">
+            <summary>
+            Add a Servant Locator to this object adapter.
+            Adding a servant
+            locator for a category for which a servant locator is already
+            registered throws AlreadyRegisteredException. To dispatch
+            operation calls on servants, the object adapter tries to find a
+            servant for a given Ice object identity and facet in the
+            following order:
+            
+            
+            
+            The object adapter tries to find a servant for the identity
+            and facet in the Active Servant Map.
+            
+            If no servant has been found in the Active Servant Map,
+            the object adapter tries to find a servant locator for the
+            category component of the identity. If a locator is found, the
+            object adapter tries to find a servant using this locator.
+            
+            If no servant has been found by any of the preceding steps,
+            the object adapter tries to find a locator for an empty category,
+            regardless of the category contained in the identity. If a
+            locator is found, the object adapter tries to find a servant
+            using this locator.
+            
+            If no servant has been found by any of the preceding steps,
+            the object adapter gives up and the caller receives
+            ObjectNotExistException or FacetNotExistException.
+            
+            
+            
+            Only one locator for the empty category can be
+            installed.
+            
+            </summary>
+            <param name="locator">The locator to add.
+            
+            </param>
+            <param name="category">The category for which the Servant Locator can
+            locate servants, or an empty string if the Servant Locator does
+            not belong to any specific category.
+            
+            </param>
+        </member>
+        <member name="M:Ice.ObjectAdapter.removeServantLocator(System.String)">
+            <summary>
+            Remove a Servant Locator from this object adapter.
+            </summary>
+            <param name="category">The category for which the Servant Locator can
+            locate servants, or an empty string if the Servant Locator does
+            not belong to any specific category.
+            
+            </param>
+            <returns>The Servant Locator, or throws NotRegisteredException
+            if no Servant Locator was found for the given category.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.findServantLocator(System.String)">
+            <summary>
+            Find a Servant Locator installed with this object adapter.
+            </summary>
+            <param name="category">The category for which the Servant Locator can
+            locate servants, or an empty string if the Servant Locator does
+            not belong to any specific category.
+            
+            </param>
+            <returns>The Servant Locator, or null if no Servant Locator was
+            found for the given category.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.findDefaultServant(System.String)">
+            <summary>
+            Find the default servant for a specific category.
+            </summary>
+            <param name="category">The category of the default servant to find.
+            
+            </param>
+            <returns>The default servant or null if no default servant was
+            registered for the category.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.createProxy(Ice.Identity)">
+            <summary>
+            Create a proxy for the object with the given identity.
+            If this
+            object adapter is configured with an adapter id, the return
+            value is an indirect proxy that refers to the adapter id. If
+            a replica group id is also defined, the return value is an
+            indirect proxy that refers to the replica group id. Otherwise,
+            if no adapter id is defined, the return value is a direct
+            proxy containing this object adapter's published endpoints.
+            
+            </summary>
+            <param name="id">The object's identity.
+            
+            </param>
+            <returns>A proxy for the object with the given identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.createDirectProxy(Ice.Identity)">
+            <summary>
+            Create a direct proxy for the object with the given identity.
+            The returned proxy contains this object adapter's published
+            endpoints.
+            
+            </summary>
+            <param name="id">The object's identity.
+            
+            </param>
+            <returns>A proxy for the object with the given identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.createIndirectProxy(Ice.Identity)">
+            <summary>
+            Create an indirect proxy for the object with the given identity.
+            If this object adapter is configured with an adapter id, the
+            return value refers to the adapter id. Otherwise, the return
+            value contains only the object identity.
+            
+            </summary>
+            <param name="id">The object's identity.
+            
+            </param>
+            <returns>A proxy for the object with the given identity.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.setLocator(Ice.LocatorPrx)">
+            <summary>
+            Set an Ice locator for this object adapter.
+            By doing so, the
+            object adapter will register itself with the locator registry
+            when it is activated for the first time. Furthermore, the proxies
+            created by this object adapter will contain the adapter identifier
+            instead of its endpoints. The adapter identifier must be configured
+            using the AdapterId property.
+            
+            </summary>
+            <param name="loc">The locator used by this object adapter.
+            
+            </param>
+        </member>
+        <member name="M:Ice.ObjectAdapter.getLocator">
+            <summary>
+            Get the Ice locator used by this object adapter.
+            </summary>
+            <returns> The locator used by this object adapter, or null if no locator is
+            used by this object adapter.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.refreshPublishedEndpoints">
+            <summary>
+            Refresh the set of published endpoints.
+            The run time re-reads
+            the PublishedEndpoints property if it is set and re-reads the
+            list of local interfaces if the adapter is configured to listen
+            on all endpoints. This operation is useful to refresh the endpoint
+            information that is published in the proxies that are created by
+            an object adapter if the network interfaces used by a host changes.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectAdapter.getEndpoints">
+            <summary>
+            Get the set of endpoints configured with this object adapter.
+            </summary>
+            <returns>The set of endpoints.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ObjectAdapter.getPublishedEndpoints">
+            <summary>
+            Get the set of endpoints that proxies created by this object
+            adapter will contain.
+            </summary>
+            <returns>The set of published endpoints.
+            
+            </returns>
+        </member>
+        <member name="T:Ice.Optional`1">
+            <summary>
+            Encapsulates an optional value. Instances of this type are immutable.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.#ctor(Ice.NoneType)">
+            <summary>
+            Creates an optional value whose state is unset.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.#ctor(`0)">
+            <summary>
+            Creates an optional value and sets its value to the given argument.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.#ctor(Ice.Optional{`0})">
+            <summary>
+            Creates an optional value whose state is copied from the given argument.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the exception with serialized data.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="M:Ice.Optional`1.op_Explicit(Ice.Optional{`0})~`0">
+            <summary>
+            Conversion operator to the underlying type; a cast is required. An exception
+            is raised if no value is set.
+            </summary>
+            <returns>The encapsulated value.</returns>
+            <exception cref="T:System.InvalidOperationException">Thrown if no value is set.</exception>
+        </member>
+        <member name="M:Ice.Optional`1.op_Implicit(`0)~Ice.Optional{`0}">
+            <summary>
+            Conversion operator from a value of the underlying type; no cast is required.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.op_Implicit(Ice.NoneType)~Ice.Optional{`0}">
+            <summary>
+            Conversion operator from a None value; no cast is required.
+            </summary>
+        </member>
+        <member name="M:Ice.Optional`1.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes an optional value.
+            </summary>
+            <param name="info">Holds the serialized object data about the exception being thrown.</param>
+            <param name="context">Contains contextual information about the source or destination.</param>
+        </member>
+        <member name="P:Ice.Optional`1.Value">
+            <summary>
+            Reads and writes the encapsulated value.
+            </summary>
+            <exception cref="T:System.InvalidOperationException">Thrown if the property is read and no value is
+            set.</exception>
+        </member>
+        <member name="P:Ice.Optional`1.HasValue">
+            <summary>
+            Determines whether a value is set.
+            </summary>
+            <returns>True if a value is set, false otherwise.</returns>
+        </member>
+        <member name="T:Ice.OptionalPatcher`1">
+            <summary>
+            Handles callbacks for an optional object parameter.
+            </summary>
+        </member>
+        <member name="T:Ice.ReadObjectCallback">
+            <summary>
+            Callback class to inform an application when a Slice class has been unmarshaled
+            from an input stream.
+            </summary>
+        </member>
+        <member name="M:Ice.ReadObjectCallback.invoke(Ice.Object)">
+            <summary>
+            The Ice run time calls this method when it has fully unmarshaled the state
+            of a Slice class.
+            </summary>
+            <param name="obj">The unmarshaled Slice class.</param>
+        </member>
+        <member name="M:Ice.OptionalPatcher`1.#ctor(System.String)">
+            <summary>
+            Instantiates the class with the given optional.
+            </summary>
+            <param name="type">The Slice type ID corresponding to the formal type.</param>
+        </member>
+        <member name="M:Ice.OptionalPatcher`1.patch(Ice.Object)">
+            <summary>
+            Sets the Ice object of the optional to the passed instance.
+            </summary>
+            <param name="v">The new object for the optional.</param>
+        </member>
+        <member name="F:Ice.OptionalPatcher`1.value">
+            <summary>
+            The target optional.
+            </summary>
+        </member>
+        <member name="T:Ice.OptionalFormat">
+             <summary>
+             The optional format.
+            
+             An optional value is encoded with a specific optional format. This optional
+             format describes how the data is encoded and how it can be skipped by the
+             unmarshaling code if the optional is not known to the receiver.
+             </summary>
+        </member>
+        <member name="T:Ice.PluginFactory">
+            <summary>
+            Applications implement this interface to provide a plug-in factory
+            to the Ice run time.
+            </summary>
+        </member>
+        <member name="M:Ice.PluginFactory.create(Ice.Communicator,System.String,System.String[])">
+             <summary>
+             Called by the Ice run time to create a new plug-in.
+             </summary>
+            
+             <param name="communicator">The communicator that is in the process of being initialized.</param>
+             <param name="name">The name of the plug-in.</param>
+             <param name="args">The arguments that are specified in the plug-ins configuration.</param>
+             <returns>The plug-in that was created by this method.</returns>
+        </member>
+        <member name="M:Ice.PluginManager.initializePlugins">
+            <summary>
+            Initialize the configured plug-ins.
+            The communicator automatically initializes
+            the plug-ins by default, but an application may need to interact directly with
+            a plug-in prior to initialization. In this case, the application must set
+            Ice.InitPlugins=0 and then invoke initializePlugins
+            manually. The plug-ins are initialized in the order in which they are loaded.
+            If a plug-in raises an exception during initialization, the communicator
+            invokes destroy on the plug-ins that have already been initialized.
+            
+            </summary>
+            <exception name="InitializationException">Raised if the plug-ins have already been initialized.</exception>
+        </member>
+        <member name="M:Ice.PluginManager.getPlugins">
+            <summary>
+            Get a list of plugins installed.
+            </summary>
+            <returns>The names of the plugins installed.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.PluginManager.getPlugin(System.String)">
+            <summary>
+            Obtain a plug-in by name.
+            </summary>
+            <param name="name">The plug-in's name.
+            
+            </param>
+            <returns>The plug-in.
+            
+            </returns>
+            <exception name="NotRegisteredException">Raised if no plug-in is found with the given name.</exception>
+        </member>
+        <member name="M:Ice.PluginManager.addPlugin(System.String,Ice.Plugin)">
+            <summary>
+            Install a new plug-in.
+            </summary>
+            <param name="name">The plug-in's name.
+            
+            </param>
+            <param name="pi">The plug-in.
+            
+            </param>
+            <exception name="AlreadyRegisteredException">Raised if a plug-in already exists with the given name.</exception>
+        </member>
+        <member name="M:Ice.PluginManager.destroy">
+            <summary>
+            Called when the communicator is being destroyed.
+            </summary>
+        </member>
+        <member name="T:Ice.ProcessOperations_">
+            <summary>
+            An administrative interface for process management.
+            Managed servers must
+            implement this interface.
+            
+            A servant implementing this interface is a potential target
+            for denial-of-service attacks, therefore proper security precautions
+            should be taken. For example, the servant can use a UUID to make its
+            identity harder to guess, and be registered in an object adapter with
+            a secured endpoint.
+            </summary>
+        </member>
+        <member name="M:Ice.ProcessOperations_.shutdown(Ice.Current)">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.ProcessOperations_.writeMessage(System.String,System.Int32,Ice.Current)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.ProcessOperationsNC_">
+            <summary>
+            An administrative interface for process management.
+            Managed servers must
+            implement this interface.
+            
+            A servant implementing this interface is a potential target
+            for denial-of-service attacks, therefore proper security precautions
+            should be taken. For example, the servant can use a UUID to make its
+            identity harder to guess, and be registered in an object adapter with
+            a secured endpoint.
+            </summary>
+        </member>
+        <member name="M:Ice.ProcessOperationsNC_.shutdown">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+        </member>
+        <member name="M:Ice.ProcessOperationsNC_.writeMessage(System.String,System.Int32)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+        </member>
+        <member name="T:Ice.PropertiesAdminOperations_">
+            <summary>
+            The PropertiesAdmin interface provides remote access to the properties
+            of a communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperations_.getProperty(System.String,Ice.Current)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            string is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperations_.getPropertiesForPrefix(System.String,Ice.Current)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            prefix is an empty string then all properties are returned.
+            
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>The matching property set.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperations_.setProperties_async(Ice.AMD_PropertiesAdmin_setProperties,System.Collections.Generic.Dictionary{System.String,System.String},Ice.Current)">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.PropertiesAdminOperationsNC_">
+            <summary>
+            The PropertiesAdmin interface provides remote access to the properties
+            of a communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperationsNC_.getProperty(System.String)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            string is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperationsNC_.getPropertiesForPrefix(System.String)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            prefix is an empty string then all properties are returned.
+            
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>The matching property set.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminOperationsNC_.setProperties_async(Ice.AMD_PropertiesAdmin_setProperties,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+        </member>
+        <member name="M:Ice.Properties.getProperty(System.String)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            string is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertyWithDefault(System.String,System.String)">
+            <summary>
+            Get a property by key.
+            If the property is not set, the
+            given default value is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="value">The default value to use if the property does not
+            exist.
+            
+            </param>
+            <returns>The property value or the default value.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertyAsInt(System.String)">
+            <summary>
+            Get a property as an integer.
+            If the property is not set, 0
+            is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value interpreted as an integer.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertyAsIntWithDefault(System.String,System.Int32)">
+            <summary>
+            Get a property as an integer.
+            If the property is not set, the
+            given default value is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="value">The default value to use if the property does not
+            exist.
+            
+            </param>
+            <returns>The property value interpreted as an integer, or the
+            default value.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertyAsList(System.String)">
+            <summary>
+            Get a property as a list of strings.
+            The strings must be
+            separated by whitespace or comma. If the property is not set,
+            an empty list is returned. The strings in the list can contain
+            whitespace and commas if they are enclosed in single or double 
+            quotes. If quotes are mismatched, an empty list is returned.
+            Within single quotes or double quotes, you can escape the
+            quote in question with \, e.g. O'Reilly can be written as
+            O'Reilly, "O'Reilly" or 'O\'Reilly'.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value interpreted as a list of strings.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertyAsListWithDefault(System.String,System.String[])">
+            <summary>
+            Get a property as a list of strings.
+            The strings must be
+            separated by whitespace or comma. If the property is not set,
+            the default list is returned. The strings in the list can contain
+            whitespace and commas if they are enclosed in single or double 
+            quotes. If quotes are mismatched, the default list is returned.
+            Within single quotes or double quotes, you can escape the
+            quote in question with \, e.g. O'Reilly can be written as
+            O'Reilly, "O'Reilly" or 'O\'Reilly'.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="value">The default value to use if the property is not set.
+            
+            </param>
+            <returns>The property value interpreted as list of strings, or the
+            default value.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.Properties.getPropertiesForPrefix(System.String)">
+            <summary>
+            Get all properties whose keys begins with
+            prefix.
+            If
+            prefix is an empty string,
+            then all properties are returned.
+            
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>The matching property set.</returns>
+        </member>
+        <member name="M:Ice.Properties.setProperty(System.String,System.String)">
+            <summary>
+            Set a property.
+            To unset a property, set it to
+            the empty string.
+            
+            </summary>
+            <param name="key">The property key.
+            </param>
+            <param name="value">The property value.
+            
+            </param>
+        </member>
+        <member name="M:Ice.Properties.getCommandLineOptions">
+            <summary>
+            Get a sequence of command-line options that is equivalent to
+            this property set.
+            Each element of the returned sequence is
+            a command-line option of the form
+            --key=value.
+            
+            </summary>
+            <returns>The command line options for this property set.</returns>
+        </member>
+        <member name="M:Ice.Properties.parseCommandLineOptions(System.String,System.String[])">
+            <summary>
+            Convert a sequence of command-line options into properties.
+            All options that begin with
+            --prefix. are
+            converted into properties. If the prefix is empty, all options
+            that begin with -- are converted to properties.
+            
+            </summary>
+            <param name="prefix">The property prefix, or an empty string to
+            convert all options starting with --.
+            
+            </param>
+            <param name="options">The command-line options.
+            
+            </param>
+            <returns>The command-line options that do not start with the specified
+            prefix, in their original order.</returns>
+        </member>
+        <member name="M:Ice.Properties.parseIceCommandLineOptions(System.String[])">
+            <summary>
+            Convert a sequence of command-line options into properties.
+            All options that begin with one of the following prefixes
+            are converted into properties: --Ice, --IceBox, --IceGrid,
+            --IcePatch2, --IceSSL, --IceStorm, --Freeze, and --Glacier2.
+            
+            </summary>
+            <param name="options">The command-line options.
+            
+            </param>
+            <returns>The command-line options that do not start with one of
+            the listed prefixes, in their original order.</returns>
+        </member>
+        <member name="M:Ice.Properties.load(System.String)">
+            <summary>
+            Load properties from a file.
+            </summary>
+            <param name="file">The property file.</param>
+        </member>
+        <member name="M:Ice.Properties.ice_clone_">
+            <summary>
+            Create a copy of this property set.
+            </summary>
+            <returns>A copy of this property set.</returns>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_isA">
+            <summary>
+            Delegate for a successful <code>ice_isA</code> invocation.
+            <param name="ret__">True if the remote object supports the type, false otherwise.</param>
+            </summary>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_ids">
+            <summary>
+            Delegate for a successful <code>ice_ids</code> invocation.
+            <param name="ret__">The array of Slice type ids supported by the remote object.</param>
+            </summary>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_id">
+            <summary>
+            Delegate for a successful <code>ice_id</code> invocation.
+            <param name="ret__">The Slice type id of the most-derived interface supported by the remote object.</param>
+            </summary>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_ping">
+            <summary>
+            Delegate for a successful <code>ice_ping</code> invocation.
+            </summary>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_invoke">
+            <summary>
+            Delegate for a successful <code>ice_invoke</code> invocation.
+            <param name="ret__">True if the invocation succeeded, or false if the invocation
+            raised a user exception.</param>
+            <param name="outEncaps">The encoded out-parameters or user exception.</param>
+            </summary>
+        </member>
+        <member name="T:Ice.Callback_Object_ice_getConnection">
+            <summary>
+            Delegate for a successful <code>ice_getConnection</code> invocation.
+            <param name="ret__">The connection used by the proxy.</param>
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectPrx">
+            <summary>
+            Base interface of all object proxies.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getCommunicator">
+            <summary>
+            Returns the communicator that created this proxy.
+            </summary>
+            <returns>The communicator that created this proxy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isA(System.String)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id__">The type ID of the Slice interface to test against.</param>
+            <returns>True if the target object has the interface specified by id__ or derives
+            from the interface specified by id__.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isA(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id__">The type ID of the Slice interface to test against.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>True if the target object has the interface specified by id__ or derives
+            from the interface specified by id__.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_isA(System.String)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id">The type ID of the Slice interface to test against.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_isA(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id">The type ID of the Slice interface to test against.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_isA(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id">The type ID of the Slice interface to test against.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_isA(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id">The type ID of the Slice interface to test against.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_isA(Ice.AsyncResult)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_isA</code>.</param>
+            <returns>True if the object supports the Slice interface, false otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_ping">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_ping(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ping">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ping(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ping(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ping(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_ping(Ice.AsyncResult)">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_ping</code>.</param>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_ids">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_ids(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ids">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ids(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ids(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_ids(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_ids(Ice.AsyncResult)">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_ids</code>.</param>
+            <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_id">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_id(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_id">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_id(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_id(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_id(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_id(Ice.AsyncResult)">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_id</code>.</param>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Byte[]@)">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="outEncaps">The encoded out-paramaters and return value
+            for the operation. The return value follows any out-parameters.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outEncaps
+            contains the encoded user exception. If the operation raises a run-time exception,
+            it throws it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Byte[]@,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="outEncaps">The encoded out-paramaters and return value
+            for the operation. The return value follows any out-parameters.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outEncaps
+            contains the encoded user exception. If the operation raises a run-time exception,
+            it throws it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_invoke(System.String,Ice.OperationMode,System.Byte[])">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_invoke(System.String,Ice.OperationMode,System.Byte[],Ice.AsyncCallback,System.Object)">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_invoke(System.Byte[]@,Ice.AsyncResult)">
+            <summary>
+            Completes a dynamic invocation.
+            </summary>
+            <param name="outEncaps">The encoded out parameters or user exception.</param>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_invoke</code>.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outEncaps
+            contains the encoded user exception. If the operation raises a run-time exception,
+            it throws it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getIdentity">
+            <summary>
+            Returns the identity embedded in this proxy.
+            <returns>The identity of the target object.</returns>
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_identity(Ice.Identity)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the per-proxy context.
+            <param name="newIdentity">The identity for the new proxy.</param>
+            <returns>The proxy with the new identity.</returns>
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getContext">
+            <summary>
+            Returns the per-proxy context for this proxy.
+            </summary>
+            <returns>The per-proxy context. If the proxy does not have a per-proxy (implicit) context, the return value
+            is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_context(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the per-proxy context.
+            </summary>
+            <param name="newContext">The context for the new proxy.</param>
+            <returns>The proxy with the new per-proxy context.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getFacet">
+            <summary>
+            Returns the facet for this proxy.
+            </summary>
+            <returns>The facet for this proxy. If the proxy uses the default facet, the return value is the
+            empty string.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_facet(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the facet.
+            </summary>
+            <param name="newFacet">The facet for the new proxy.</param>
+            <returns>The proxy with the new facet.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getAdapterId">
+            <summary>
+            Returns the adapter ID for this proxy.
+            </summary>
+            <returns>The adapter ID. If the proxy does not have an adapter ID, the return value is the
+            empty string.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_adapterId(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the adapter ID.
+            </summary>
+            <param name="newAdapterId">The adapter ID for the new proxy.</param>
+            <returns>The proxy with the new adapter ID.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getEndpoints">
+            <summary>
+            Returns the endpoints used by this proxy.
+            </summary>
+            <returns>The endpoints used by this proxy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_endpoints(Ice.Endpoint[])">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the endpoints.
+            </summary>
+            <param name="newEndpoints">The endpoints for the new proxy.</param>
+            <returns>The proxy with the new endpoints.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getLocatorCacheTimeout">
+            <summary>
+            Returns the locator cache timeout of this proxy.
+            </summary>
+            <returns>The locator cache timeout value (in seconds).</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_locatorCacheTimeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the locator cache timeout.
+            </summary>
+            <param name="timeout">The new locator cache timeout (in seconds).</param>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_invocationTimeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the invocation timeout.
+            </summary>
+            <param name="timeout">The new invocation timeout (in seconds).</param>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getInvocationTimeout">
+            <summary>
+            Returns the invocation timeout of this proxy.
+            </summary>
+            <returns>The invocation timeout value (in seconds).</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isConnectionCached">
+            <summary>
+            Returns whether this proxy caches connections.
+            </summary>
+            <returns>True if this proxy caches connections; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_connectionCached(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for connection caching.
+            </summary>
+            <param name="newCache">True if the new proxy should cache connections; false, otherwise.</param>
+            <returns>The new proxy with the specified caching policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getEndpointSelection">
+            <summary>
+            Returns how this proxy selects endpoints (randomly or ordered).
+            </summary>
+            <returns>The endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_endpointSelection(Ice.EndpointSelectionType)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the endpoint selection policy.
+            </summary>
+            <param name="newType">The new endpoint selection policy.</param>
+            <returns>The new proxy with the specified endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isSecure">
+            <summary>
+            Returns whether this proxy communicates only via secure endpoints.
+            </summary>
+            <returns>True if this proxy communicates only vi secure endpoints; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_secure(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for how it selects endpoints.
+            </summary>
+            <param name="b"> If b is true, only endpoints that use a secure transport are
+            used by the new proxy. If b is false, the returned proxy uses both secure and insecure
+            endpoints.</param>
+            <returns>The new proxy with the specified selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_encodingVersion(Ice.EncodingVersion)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the encoding used to marshal
+            parameters.
+            </summary>
+            <param name="e">The encoding version to use to marshal requests parameters.</param>
+            <returns>The new proxy with the specified encoding version.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getEncodingVersion">
+            <summary>Returns the encoding version used to marshal requests parameters.</summary>
+            <returns>The encoding version.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isPreferSecure">
+            <summary>
+            Returns whether this proxy prefers secure endpoints.
+            </summary>
+            <returns>True if the proxy always attempts to invoke via secure endpoints before it
+            attempts to use insecure endpoints; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_preferSecure(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its endpoint selection policy.
+            </summary>
+            <param name="b">If b is true, the new proxy will use secure endpoints for invocations
+            and only use insecure endpoints if an invocation cannot be made via secure endpoints. If b is
+            false, the proxy prefers insecure endpoints to secure ones.</param>
+            <returns>The new proxy with the new endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getRouter">
+            <summary>
+            Returns the router for this proxy.
+            </summary>
+            <returns>The router for the proxy. If no router is configured for the proxy, the return value
+            is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_router(Ice.RouterPrx)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the router.
+            </summary>
+            <param name="router">The router for the new proxy.</param>
+            <returns>The new proxy with the specified router.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getLocator">
+            <summary>
+            Returns the locator for this proxy.
+            </summary>
+            <returns>The locator for this proxy. If no locator is configured, the return value is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_locator(Ice.LocatorPrx)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the locator.
+            </summary>
+            <param name="locator">The locator for the new proxy.</param>
+            <returns>The new proxy with the specified locator.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isCollocationOptimized">
+            <summary>
+            Returns whether this proxy uses collocation optimization.
+            </summary>
+            <returns>True if the proxy uses collocation optimization; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_collocationOptimized(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for collocation optimization.
+            </summary>
+            <param name="b">True if the new proxy enables collocation optimization; false, otherwise.</param>
+            <returns>The new proxy the specified collocation optimization.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_twoway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses twoway invocations.
+            </summary>
+            <returns>A new proxy that uses twoway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isTwoway">
+            <summary>
+            Returns whether this proxy uses twoway invocations.
+            </summary>
+            <returns>True if this proxy uses twoway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_oneway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses oneway invocations.
+            </summary>
+            <returns>A new proxy that uses oneway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isOneway">
+            <summary>
+            Returns whether this proxy uses oneway invocations.
+            </summary>
+            <returns>True if this proxy uses oneway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_batchOneway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses batch oneway invocations.
+            </summary>
+            <returns>A new proxy that uses batch oneway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isBatchOneway">
+            <summary>
+            Returns whether this proxy uses batch oneway invocations.
+            </summary>
+            <returns>True if this proxy uses batch oneway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_datagram">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses datagram invocations.
+            </summary>
+            <returns>A new proxy that uses datagram invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isDatagram">
+            <summary>
+            Returns whether this proxy uses datagram invocations.
+            </summary>
+            <returns>True if this proxy uses datagram invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_batchDatagram">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses batch datagram invocations.
+            </summary>
+            <returns>A new proxy that uses batch datagram invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_isBatchDatagram">
+            <summary>
+            Returns whether this proxy uses batch datagram invocations.
+            </summary>
+            <returns>True if this proxy uses batch datagram invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_compress(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for compression.
+            </summary>
+            <param name="co">True enables compression for the new proxy; false disables compression.</param>
+            <returns>A new proxy with the specified compression setting.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_timeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its timeout setting.
+            </summary>
+            <param name="t">The timeout for the new proxy in milliseconds.</param>
+            <returns>A new proxy with the specified timeout.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_connectionId(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its connection ID.
+            </summary>
+            <param name="connectionId">The connection ID for the new proxy. An empty string removes the
+            connection ID.</param>
+            <returns>A new proxy with the specified connection ID.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getConnectionId">
+            <summary>
+            Returns the connection id of this proxy.
+            </summary>
+            <returns>The connection id.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getConnection">
+            <summary>
+            Returns the Connection for this proxy. If the proxy does not yet have an established connection,
+            it first attempts to create a connection.
+            </summary>
+            <returns>The Connection for this proxy.</returns>
+            <exception name="CollocationOptimizationException">If the proxy uses collocation optimization and denotes a
+            collocated object.</exception>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_getConnection">
+            <summary>
+            Asynchronously gets the connection for this proxy.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.begin_ice_getConnection(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Asynchronously gets the connection for this proxy.
+            </summary>
+            <param name="cb__">A callback to be invoked when the invocation completes.</param>
+            <param name="cookie__">Application-specific data to be stored in the result.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.end_ice_getConnection(Ice.AsyncResult)">
+            <summary>
+            Asynchronously gets the connection for this proxy.
+            </summary>
+            <param name="r__">The asynchronous result object returned by <code>begin_ice_getConnection</code>.</param>
+            <returns>The connection.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_getCachedConnection">
+            <summary>
+            Returns the cached Connection for this proxy. If the proxy does not yet have an established
+            connection, it does not attempt to create a connection.
+            </summary>
+            <returns>The cached Connection for this proxy (null if the proxy does not have
+            an established connection).</returns>
+            <exception name="CollocationOptimizationException">If the proxy uses collocation optimization and denotes a
+            collocated object.</exception>
+        </member>
+        <member name="M:Ice.ObjectPrx.ice_flushBatchRequests">
+            <summary>
+            Flushes any pending batched requests for this communicator. The call blocks until the flush is complete.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectPrxHelperBase">
+            <summary>
+            Base class of all object proxies.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.GetHashCode">
+            <summary>
+            Returns a hash code for this proxy.
+            </summary>
+            <returns>The hash code.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getCommunicator">
+            <summary>
+            Returns the communicator that created this proxy.
+            </summary>
+            <returns>The communicator that created this proxy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ToString">
+            <summary>
+            Returns the stringified form of this proxy.
+            </summary>
+            <returns>The stringified proxy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isA(System.String)">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id__">The type ID of the Slice interface to test against.</param>
+            <returns>True if the target object has the interface specified by id__ or derives
+            from the interface specified by id__.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isA(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether this object supports a specific Slice interface.
+            </summary>
+            <param name="id__">The type ID of the Slice interface to test against.</param>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>True if the target object has the interface specified by id__ or derives
+            from the interface specified by id__.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_ping">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_ping(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Tests whether the target object of this proxy can be reached.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_ids">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_ids(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+            order. The first element of the returned array is always ::Ice::Object.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_id">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_id(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+            </summary>
+            <param name="context__">The context dictionary for the invocation.</param>
+            <returns>The Slice type ID of the most-derived interface.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Byte[]@)">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="outEncaps">The encoded out-paramaters and return value
+            for the operation. The return value follows any out-parameters.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outEncaps
+            contains the encoded user exception. If the operation raises a run-time exception,
+            it throws it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_invoke(System.String,Ice.OperationMode,System.Byte[],System.Byte[]@,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Invokes an operation dynamically.
+            </summary>
+            <param name="operation">The name of the operation to invoke.</param>
+            <param name="mode">The operation mode (normal or idempotent).</param>
+            <param name="inEncaps">The encoded in-parameters for the operation.</param>
+            <param name="outEncaps">The encoded out-paramaters and return value
+            for the operation. The return value follows any out-parameters.</param>
+            <param name="context">The context dictionary for the invocation.</param>
+            <returns>If the operation completed successfully, the return value
+            is true. If the operation raises a user exception,
+            the return value is false; in this case, outEncaps
+            contains the encoded user exception. If the operation raises a run-time exception,
+            it throws it directly.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getIdentity">
+            <summary>
+            Returns the identity embedded in this proxy.
+            <returns>The identity of the target object.</returns>
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_identity(Ice.Identity)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the per-proxy context.
+            <param name="newIdentity">The identity for the new proxy.</param>
+            <returns>The proxy with the new identity.</returns>
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getContext">
+            <summary>
+            Returns the per-proxy context for this proxy.
+            </summary>
+            <returns>The per-proxy context. If the proxy does not have a per-proxy (implicit) context, the return value
+            is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_context(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the per-proxy context.
+            </summary>
+            <param name="newContext">The context for the new proxy.</param>
+            <returns>The proxy with the new per-proxy context.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getFacet">
+            <summary>
+            Returns the facet for this proxy.
+            </summary>
+            <returns>The facet for this proxy. If the proxy uses the default facet, the return value is the
+            empty string.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_facet(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the facet.
+            </summary>
+            <param name="newFacet">The facet for the new proxy.</param>
+            <returns>The proxy with the new facet.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getAdapterId">
+            <summary>
+            Returns the adapter ID for this proxy.
+            </summary>
+            <returns>The adapter ID. If the proxy does not have an adapter ID, the return value is the
+            empty string.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_adapterId(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the adapter ID.
+            </summary>
+            <param name="newAdapterId">The adapter ID for the new proxy.</param>
+            <returns>The proxy with the new adapter ID.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getEndpoints">
+            <summary>
+            Returns the endpoints used by this proxy.
+            </summary>
+            <returns>The endpoints used by this proxy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_endpoints(Ice.Endpoint[])">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the endpoints.
+            </summary>
+            <param name="newEndpoints">The endpoints for the new proxy.</param>
+            <returns>The proxy with the new endpoints.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getLocatorCacheTimeout">
+            <summary>
+            Returns the locator cache timeout of this proxy.
+            </summary>
+            <returns>The locator cache timeout value (in seconds).</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_locatorCacheTimeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the locator cache timeout.
+            </summary>
+            <param name="newTimeout">The new locator cache timeout (in seconds).</param>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getInvocationTimeout">
+            <summary>
+            Returns the invocation timeout of this proxy.
+            </summary>
+            <returns>The invocation timeout value (in seconds).</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_invocationTimeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the invocation timeout.
+            </summary>
+            <param name="newTimeout">The new invocation timeout (in seconds).</param>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isConnectionCached">
+            <summary>
+            Returns whether this proxy caches connections.
+            </summary>
+            <returns>True if this proxy caches connections; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_connectionCached(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for connection caching.
+            </summary>
+            <param name="newCache">True if the new proxy should cache connections; false, otherwise.</param>
+            <returns>The new proxy with the specified caching policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getEndpointSelection">
+            <summary>
+            Returns how this proxy selects endpoints (randomly or ordered).
+            </summary>
+            <returns>The endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_endpointSelection(Ice.EndpointSelectionType)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the endpoint selection policy.
+            </summary>
+            <param name="newType">The new endpoint selection policy.</param>
+            <returns>The new proxy with the specified endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isSecure">
+            <summary>
+            Returns whether this proxy communicates only via secure endpoints.
+            </summary>
+            <returns>True if this proxy communicates only vi secure endpoints; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_secure(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for how it selects endpoints.
+            </summary>
+            <param name="b"> If b is true, only endpoints that use a secure transport are
+            used by the new proxy. If b is false, the returned proxy uses both secure and insecure
+            endpoints.</param>
+            <returns>The new proxy with the specified selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_encodingVersion(Ice.EncodingVersion)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the encoding used to marshal
+            parameters.
+            </summary>
+            <param name="e">The encoding version to use to marshal requests parameters.</param>
+            <returns>The new proxy with the specified encoding version.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getEncodingVersion">
+            <summary>Returns the encoding version used to marshal requests parameters.</summary>
+            <returns>The encoding version.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isPreferSecure">
+            <summary>
+            Returns whether this proxy prefers secure endpoints.
+            </summary>
+            <returns>True if the proxy always attempts to invoke via secure endpoints before it
+            attempts to use insecure endpoints; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_preferSecure(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its endpoint selection policy.
+            </summary>
+            <param name="b">If b is true, the new proxy will use secure endpoints for invocations
+            and only use insecure endpoints if an invocation cannot be made via secure endpoints. If b is
+            false, the proxy prefers insecure endpoints to secure ones.</param>
+            <returns>The new proxy with the new endpoint selection policy.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getRouter">
+            <summary>
+            Returns the router for this proxy.
+            </summary>
+            <returns>The router for the proxy. If no router is configured for the proxy, the return value
+            is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_router(Ice.RouterPrx)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the router.
+            </summary>
+            <param name="router">The router for the new proxy.</param>
+            <returns>The new proxy with the specified router.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getLocator">
+            <summary>
+            Returns the locator for this proxy.
+            </summary>
+            <returns>The locator for this proxy. If no locator is configured, the return value is null.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_locator(Ice.LocatorPrx)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for the locator.
+            </summary>
+            <param name="locator">The locator for the new proxy.</param>
+            <returns>The new proxy with the specified locator.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isCollocationOptimized">
+            <summary>
+            Returns whether this proxy uses collocation optimization.
+            </summary>
+            <returns>True if the proxy uses collocation optimization; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_collocationOptimized(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for collocation optimization.
+            </summary>
+            <param name="b">True if the new proxy enables collocation optimization; false, otherwise.</param>
+            <returns>The new proxy the specified collocation optimization.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_twoway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses twoway invocations.
+            </summary>
+            <returns>A new proxy that uses twoway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isTwoway">
+            <summary>
+            Returns whether this proxy uses twoway invocations.
+            </summary>
+            <returns>True if this proxy uses twoway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_oneway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses oneway invocations.
+            </summary>
+            <returns>A new proxy that uses oneway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isOneway">
+            <summary>
+            Returns whether this proxy uses oneway invocations.
+            </summary>
+            <returns>True if this proxy uses oneway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_batchOneway">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses batch oneway invocations.
+            </summary>
+            <returns>A new proxy that uses batch oneway invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isBatchOneway">
+            <summary>
+            Returns whether this proxy uses batch oneway invocations.
+            </summary>
+            <returns>True if this proxy uses batch oneway invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_datagram">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses datagram invocations.
+            </summary>
+            <returns>A new proxy that uses datagram invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isDatagram">
+            <summary>
+            Returns whether this proxy uses datagram invocations.
+            </summary>
+            <returns>True if this proxy uses datagram invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_batchDatagram">
+            <summary>
+            Creates a new proxy that is identical to this proxy, but uses batch datagram invocations.
+            </summary>
+            <returns>A new proxy that uses batch datagram invocations.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_isBatchDatagram">
+            <summary>
+            Returns whether this proxy uses batch datagram invocations.
+            </summary>
+            <returns>True if this proxy uses batch datagram invocations; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_compress(System.Boolean)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for compression.
+            </summary>
+            <param name="co">True enables compression for the new proxy; false disables compression.</param>
+            <returns>A new proxy with the specified compression setting.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_timeout(System.Int32)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its timeout setting.
+            </summary>
+            <param name="t">The timeout for the new proxy in milliseconds.</param>
+            <returns>A new proxy with the specified timeout.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_connectionId(System.String)">
+            <summary>
+            Creates a new proxy that is identical to this proxy, except for its connection ID.
+            </summary>
+            <param name="connectionId">The connection ID for the new proxy. An empty string removes the
+            connection ID.</param>
+            <returns>A new proxy with the specified connection ID.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getConnectionId">
+            <summary>
+            Returns the connection id of this proxy.
+            </summary>
+            <returns>The connection id.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getConnection">
+            <summary>
+            Returns the Connection for this proxy. If the proxy does not yet have an established connection,
+            it first attempts to create a connection.
+            </summary>
+            <returns>The Connection for this proxy.</returns>
+            <exception name="CollocationOptimizationException">If the proxy uses collocation optimization and denotes a
+            collocated object.</exception>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_getCachedConnection">
+            <summary>
+            Returns the cached Connection for this proxy. If the proxy does not yet have an established
+            connection, it does not attempt to create a connection.
+            </summary>
+            <returns>The cached Connection for this proxy (null if the proxy does not have
+            an established connection).</returns>
+            <exception name="CollocationOptimizationException">If the proxy uses collocation optimization and denotes a
+            collocated object.</exception>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.ice_flushBatchRequests">
+            <summary>
+            Flushes any pending batched requests for this communicator. The call blocks until the flush is complete.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.Equals(System.Object)">
+            <summary>
+            Returns whether this proxy equals the passed object. Two proxies are equal if they are equal in all
+            respects, that is, if their object identity, endpoints timeout settings, and so on are all equal.
+            </summary>
+            <param name="r">The object to compare this proxy with.</param>
+            <returns>True if this proxy is equal to r; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.Equals(Ice.ObjectPrxHelperBase,Ice.ObjectPrxHelperBase)">
+            <summary>
+            Returns whether two proxies are equal. Two proxies are equal if they are equal in all
+            respects, that is, if their object identity, endpoints timeout settings, and so on are all equal.
+            </summary>
+            <param name="lhs">A proxy to compare with the proxy rhs.</param>
+            <param name="rhs">A proxy to compare with the proxy lhs.</param>
+            <returns>True if the proxies are equal; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.op_Equality(Ice.ObjectPrxHelperBase,Ice.ObjectPrxHelperBase)">
+            <summary>
+            Returns whether two proxies are equal. Two proxies are equal if they are equal in all
+            respects, that is, if their object identity, endpoints timeout settings, and so on are all equal.
+            </summary>
+            <param name="lhs">A proxy to compare with the proxy rhs.</param>
+            <param name="rhs">A proxy to compare with the proxy lhs.</param>
+            <returns>True if the proxies are equal; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelperBase.op_Inequality(Ice.ObjectPrxHelperBase,Ice.ObjectPrxHelperBase)">
+            <summary>
+            Returns whether two proxies are not equal. Two proxies are equal if they are equal in all
+            respects, that is, if their object identity, endpoints timeout settings, and so on are all equal.
+            </summary>
+            <param name="lhs">A proxy to compare with the proxy rhs.</param>
+            <param name="rhs">A proxy to compare with the proxy lhs.</param>
+            <returns>True if the proxies are not equal; false, otherwise.</returns>
+        </member>
+        <member name="T:Ice.ObjectPrxHelper">
+            <summary>
+            Base class for all proxy helpers.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.checkedCast(Ice.ObjectPrx)">
+            <summary>
+            Casts a proxy to {@link ObjectPrx}. This call contacts
+            the server and will throw an Ice run-time exception if the target
+            object does not exist or the server cannot be reached.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <returns>b.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.checkedCast(Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Casts a proxy to {@link ObjectPrx}. This call contacts
+            the server and throws an Ice run-time exception if the target
+            object does not exist or the server cannot be reached.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <param name="ctx">The Context map for the invocation.</param>
+            <returns>b.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.checkedCast(Ice.ObjectPrx,System.String)">
+            <summary>
+            Creates a new proxy that is identical to the passed proxy, except
+            for its facet. This call contacts
+            the server and throws an Ice run-time exception if the target
+            object does not exist, the specified facet does not exist, or the server cannot be reached.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <param name="f">The facet for the new proxy.</param>
+            <returns>The new proxy with the specified facet.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.checkedCast(Ice.ObjectPrx,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Creates a new proxy that is identical to the passed proxy, except
+            for its facet. This call contacts
+            the server and throws an Ice run-time exception if the target
+            object does not exist, the specified facet does not exist, or the server cannot be reached.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <param name="f">The facet for the new proxy.</param>
+            <param name="ctx">The Context map for the invocation.</param>
+            <returns>The new proxy with the specified facet.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.uncheckedCast(Ice.ObjectPrx)">
+            <summary>
+            Casts a proxy to {@link ObjectPrx}. This call does
+            not contact the server and always succeeds.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <returns>b.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.uncheckedCast(Ice.ObjectPrx,System.String)">
+            <summary>
+            Creates a new proxy that is identical to the passed proxy, except
+            for its facet. This call does not contact the server and always succeeds.
+            </summary>
+            <param name="b">The proxy to cast to ObjectPrx.</param>
+            <param name="f">The facet for the new proxy.</param>
+            <returns>The new proxy with the specified facet.</returns>
+        </member>
+        <member name="M:Ice.ObjectPrxHelper.ice_staticId">
+            <summary>
+            Returns the Slice type id of the interface or class associated
+            with this proxy class.
+            </summary>
+            <returns>The type id, "::Ice::Object".</returns>
+        </member>
+        <member name="T:Ice.ProxyIdentityKey">
+            <summary>
+            This class allows a proxy to be used as the key for a hashed collection.
+            The GetHashCode, Equals, and Compare methods are based on the object identity
+            of the proxy.
+            </summary>
+        </member>
+        <member name="M:Ice.ProxyIdentityKey.GetHashCode(System.Object)">
+            <summary>
+            Computes a hash value based on the object identity of the proxy.
+            </summary>
+            <param name="obj">The proxy whose hash value to compute.</param>
+            <returns>The hash value for the proxy based on the identity.</returns>
+        </member>
+        <member name="M:Ice.ProxyIdentityKey.Equals(System.Object,System.Object)">
+            Compares two proxies for equality.
+            <param name="obj1">A proxy to compare.</param>
+            <param name="obj2">A proxy to compare.</param>
+            <returns>True if the passed proxies have the same object
+            identity; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ProxyIdentityKey.Compare(System.Object,System.Object)">
+            Compares two proxies using the object identity for comparison.
+            <param name="obj1">A proxy to compare.</param>
+            <param name="obj2">A proxy to compare.</param>
+            <returns>&lt; 0 if obj1 is less than obj2; &gt; 0 if obj1 is greater than obj2;
+            0, otherwise.</returns>
+        </member>
+        <member name="T:Ice.ProxyIdentityFacetKey">
+            <summary>
+            This class allows a proxy to be used as the key for a hashed collection.
+            The GetHashCode, Equals, and Compare methods are based on the object identity and
+            the facet of the proxy.
+            </summary>
+        </member>
+        <member name="M:Ice.ProxyIdentityFacetKey.GetHashCode(System.Object)">
+            <summary>
+            Computes a hash value based on the object identity and facet of the proxy.
+            </summary>
+            <param name="obj">The proxy whose hash value to compute.</param>
+            <returns>The hash value for the proxy based on the identity and facet.</returns>
+        </member>
+        <member name="M:Ice.ProxyIdentityFacetKey.Equals(System.Object,System.Object)">
+            Compares two proxies for equality.
+            <param name="obj1">A proxy to compare.</param>
+            <param name="obj2">A proxy to compare.</param>
+            <returns>True if the passed proxies have the same object
+            identity and facet; false, otherwise.</returns>
+        </member>
+        <member name="M:Ice.ProxyIdentityFacetKey.Compare(System.Object,System.Object)">
+            Compares two proxies using the object identity and facet for comparison.
+            <param name="obj1">A proxy to compare.</param>
+            <param name="obj2">A proxy to compare.</param>
+            <returns>&lt; 0 if obj1 is less than obj2; &gt; 0 if obj1 is greater than obj2;
+            0, otherwise.</returns>
+        </member>
+        <member name="T:Ice.SlicedData">
+            <summary>
+            SlicedData holds the slices of unknown class or exception types.
+            </summary>
+        </member>
+        <member name="F:Ice.SlicedData.slices">
+             The details of each slice, in order of most-derived to least-derived.
+            
+        </member>
+        <member name="T:Ice.SliceInfo">
+            <summary>
+            SliceInfo encapsulates the details of a slice for an unknown class or exception type.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.typeId">
+            <summary>
+            The Slice type ID for this slice.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.compactId">
+            <summary>
+            The Slice compact type ID for this slice.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.bytes">
+            <summary>
+            The encoded bytes for this slice, including the leading size integer.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.objects">
+            <summary>
+            The Ice objects referenced by this slice.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.hasOptionalMembers">
+            <summary>
+            Whether or not the slice contains optional members.
+            </summary>
+        </member>
+        <member name="F:Ice.SliceInfo.isLastSlice">
+            <summary>
+            Whether or not this is the last slice.
+            </summary>
+        </member>
+        <member name="T:Ice.InputStream">
+            <summary>
+            Interface for input streams used to extract Slice types from a sequence of bytes.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.communicator">
+            <summary>
+            Returns the communicator for this input stream.
+            </summary>
+            <returns>The communicator.</returns>
+        </member>
+        <member name="M:Ice.InputStream.sliceObjects(System.Boolean)">
+            <summary>
+            Determines the behavior of the stream when extracting Slice objects.
+            A Slice object is "sliced" when a factory cannot be found for a Slice type ID.
+            </summary>
+            <param name="slice">If true (the default), slicing is enabled; if false,
+            slicing is disabled. If slicing is disabled and the stream encounters a Slice type ID
+            during decoding for which no object factory is installed, it raises NoObjectFactoryException.</param>
+        </member>
+        <member name="M:Ice.InputStream.readBool">
+            <summary>
+            Extracts a boolean value from the stream.
+            </summary>
+            <returns>The extracted boolean.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readBoolSeq">
+            <summary>
+            Extracts a sequence of boolean values from the stream.
+            </summary>
+            <returns>The extracted boolean sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readByte">
+            <summary>
+            Extracts a byte value from the stream.
+            </summary>
+            <returns>The extracted byte.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readByteSeq">
+            <summary>
+            Extracts a sequence of byte values from the stream.
+            </summary>
+            <returns>The extracted byte sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readSerializable">
+            <summary>
+            Extracts a serializable .NET object from the stream.
+            </summary>
+            <returns>The deserialized .NET object.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readShort">
+            <summary>
+            Extracts a short value from the stream.
+            </summary>
+            <returns>The extracted short value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readShortSeq">
+            <summary>
+            Extracts a sequence of short values from the stream.
+            </summary>
+            <returns>The extracted short sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readInt">
+            <summary>
+            Extracts an integer value from the stream.
+            </summary>
+            <returns>The extracted integer value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readIntSeq">
+            <summary>
+            Extracts a sequence of integer values from the stream.
+            </summary>
+            <returns>The extracted integer sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readLong">
+            <summary>
+            Extracts a long value from the stream.
+            </summary>
+            <returns>The extracted long value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readLongSeq">
+            <summary>
+            Extracts a sequence of long values from the stream.
+            </summary>
+            <returns>The extracted long sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readFloat">
+            <summary>
+            Extracts a float value from the stream.
+            </summary>
+            <returns>The extracted float value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readFloatSeq">
+            <summary>
+            Extracts a sequence of float values from the stream.
+            </summary>
+            <returns>The extracted float sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readDouble">
+            <summary>
+            Extracts a double value from the stream.
+            </summary>
+            <returns>The extracted double value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readDoubleSeq">
+            <summary>
+            Extracts a sequence of double values from the stream.
+            </summary>
+            <returns>The extracted double sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readString">
+            <summary>
+            Extracts a string from the stream.
+            </summary>
+            <returns>The extracted double value.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readStringSeq">
+            <summary>
+            Extracts a sequence of strings from the stream.
+            </summary>
+            <returns>The extracted string sequence.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readSize">
+            <summary>
+            Extracts a size from the stream.
+            </summary>
+            <returns>The extracted size.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readAndCheckSeqSize(System.Int32)">
+            <summary>
+            Extracts and check a sequence size from the stream. The check ensures not too much memory will
+            be pre-allocated for the sequence.
+            </summary>
+            <param name="minSize">The minimum size of an element of the sequence.</param>
+            <returns>The extracted size.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readProxy">
+            <summary>
+            Extracts a proxy from the stream.
+            </summary>
+            <returns>The extracted proxy.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readObject(Ice.ReadObjectCallback)">
+            <summary>
+            Extracts the index of a Slice class from the stream.
+            </summary>
+            <param name="cb">The callback to notify the application when the extracted instance is available.
+            The Ice run time extracts Slice classes in stages. The Ice run time calls ReadObjectCallback.invoke
+            when the corresponding instance has been fully unmarshaled.</param>
+        </member>
+        <member name="M:Ice.InputStream.readEnum(System.Int32)">
+             <summary>
+             Read an enumerated value.
+             </summary>
+            
+             <param name="maxValue">The maximum enumerator value in the definition.</param>
+             <returns>The enumerator.</returns>
+        </member>
+        <member name="M:Ice.InputStream.throwException">
+            <summary>
+            Extracts a user exception from the stream and throws it.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.throwException(Ice.UserExceptionReaderFactory)">
+            <summary>
+            Extracts a user exception from the stream and throws it.
+            Extracts a user exception from the stream and throws it, using the supplied
+            factory to instantiate a UserExceptionReader.
+            </summary>
+            <param name="factory">A factory that creates UserExceptionReader instances.</param>
+        </member>
+        <member name="M:Ice.InputStream.startObject">
+            <summary>
+            Marks the start of an Ice object.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.endObject(System.Boolean)">
+            <summary>
+            Marks the end of an Ice object.
+            </summary>
+            <param name="preserve">True if unknown slices should be preserved, false otherwise.</param>
+            <returns>A SlicedData object containing the preserved slices for unknown types.</returns>
+        </member>
+        <member name="M:Ice.InputStream.startException">
+            <summary>
+            Marks the start of a user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.endException(System.Boolean)">
+            <summary>
+            Marks the end of a user exception.
+            </summary>
+            <param name="preserve">True if unknown slices should be preserved, false otherwise.</param>
+            <returns>A SlicedData object containing the preserved slices for unknown types.</returns>
+        </member>
+        <member name="M:Ice.InputStream.startSlice">
+            <summary>
+            Reads the start of an object or exception slice.
+            </summary>
+            <returns>The Slice type ID for this slice.</returns>
+        </member>
+        <member name="M:Ice.InputStream.endSlice">
+            <summary>
+            Indicates that the end of an object or exception slice has been reached.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.skipSlice">
+            <summary>
+            Skips over an object or exception slice.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.startEncapsulation">
+            <summary>
+            Reads the start of an encapsulation.
+            </summary>
+            <returns>The encapsulation encoding version.</returns>
+        </member>
+        <member name="M:Ice.InputStream.endEncapsulation">
+            <summary>
+            Indicates that the end of an encapsulation has been reached.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.skipEncapsulation">
+            <summary>
+            Skips over an encapsulation.
+            </summary>
+            <returns>The encapsulation encoding version.</returns>
+        </member>
+        <member name="M:Ice.InputStream.getEncoding">
+            <summary>
+            Determines the current encoding version.
+            </summary>
+            <returns>The encoding version.</returns>
+        </member>
+        <member name="M:Ice.InputStream.readPendingObjects">
+            <summary>
+            Indicates that unmarshaling is complete, except for any Slice objects. The application must
+            call this method only if the stream actually contains Slice objects. Calling readPendingObjects
+            triggers the calls to ReadObjectCallback.invoke that inform the application that unmarshaling
+            of a Slice object is complete.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.rewind">
+            <summary>
+            Resets the read position of the stream to the beginning.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.skip(System.Int32)">
+            <summary>
+            Skips ahead in the stream.
+            </summary>
+            <param name="sz">The number of bytes to skip.</param>
+        </member>
+        <member name="M:Ice.InputStream.skipSize">
+            <summary>
+            Skips over a size value.
+            </summary>
+        </member>
+        <member name="M:Ice.InputStream.readOptional(System.Int32,Ice.OptionalFormat)">
+            <summary>
+            Determine if an optional value is available for reading.
+            </summary>
+            <param name="tag">The tag associated with the value.</param>
+            <param name="format">The optional format for the value.</param>
+            <returns>True if the value is present, false otherwise.</returns>
+        </member>
+        <member name="M:Ice.InputStream.pos">
+            <summary>
+            Determine the current position in the stream.
+            </summary>
+            <returns>The current position.</returns>
+        </member>
+        <member name="M:Ice.InputStream.destroy">
+            <summary>
+            Destroys the stream and its associated resources. The application must call destroy prior
+            to releasing the last reference to a stream; failure to do so may result in resource leaks.
+            </summary>
+        </member>
+        <member name="T:Ice.OutputStream">
+            <summary>
+            Interface for output streams used to write Slice types to a sequence
+            of bytes.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.communicator">
+            <summary>
+            Returns the communicator for this output stream.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.writeBool(System.Boolean)">
+            <summary>
+            Writes a boolean to the stream.
+            </summary>
+            <param name="v">The boolean to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeBoolSeq(System.Boolean[])">
+            <summary>
+            Writes a sequence of booleans to the stream.
+            </summary>
+            <param name="v">The sequence of booleans to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeByte(System.Byte)">
+            <summary>
+            Writes a byte to the stream.
+            </summary>
+            <param name="v">The byte to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeByteSeq(System.Byte[])">
+            <summary>
+            Writes a sequence of bytes to the stream.
+            </summary>
+            <param name="v">The sequence of bytes to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeSerializable(System.Object)">
+            <summary>
+            Writes a serializable .NET object to the stream.
+            </summary>
+            <param name="v">The serializable object to write.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeShort(System.Int16)">
+            <summary>
+            Writes a short to the stream.
+            </summary>
+            <param name="v">The short to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeShortSeq(System.Int16[])">
+            <summary>
+            Writes a sequence of shorts to the stream.
+            </summary>
+            <param name="v">The sequence of shorts to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeInt(System.Int32)">
+            <summary>
+            Writes an integer to the stream.
+            </summary>
+            <param name="v">The integer to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeIntSeq(System.Int32[])">
+            <summary>
+            Writes a sequence of integers to the stream.
+            </summary>
+            <param name="v">The sequence of integers to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeLong(System.Int64)">
+            <summary>
+            Writes a long to the stream.
+            </summary>
+            <param name="v">The long to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeLongSeq(System.Int64[])">
+            <summary>
+            Writes a sequence of longs to the stream.
+            </summary>
+            <param name="v">The sequence of longs to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeFloat(System.Single)">
+            <summary>
+            Writes a float to the stream.
+            </summary>
+            <param name="v">The float to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeFloatSeq(System.Single[])">
+            <summary>
+            Writes a sequence of floats to the stream.
+            </summary>
+            <param name="v">The sequence of floats to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeDouble(System.Double)">
+            <summary>
+            Writes a double to the stream.
+            </summary>
+            <param name="v">The double to write to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeDoubleSeq(System.Double[])">
+            <summary>
+            Writes a sequence of doubles to the stream.
+            </summary>
+            <param name="v">The sequence of doubles to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeString(System.String)">
+            <summary>
+            Writes a string to the stream.
+            </summary>
+            <param name="v">The string to write to the stream.
+            Passing null causes an empty string to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeStringSeq(System.String[])">
+            <summary>
+            Writes a sequence of strings to the stream.
+            </summary>
+            <param name="v">The sequence of strings to write.
+            Passing null causes an empty sequence to be written to the stream.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeSize(System.Int32)">
+            <summary>
+            Writes a size to the stream.
+            </summary>
+            <param name="sz">The size to write.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeProxy(Ice.ObjectPrx)">
+            <summary>
+            Writes a proxy to the stream.
+            </summary>
+            <param name="v">The proxy to write.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeObject(Ice.Object)">
+            <summary>
+            Writes a Slice class to the stream.
+            </summary>
+            <param name="v">The class to write. This method writes the index of a Slice class; the state of the
+            class is written once writePendingObjects is called.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeEnum(System.Int32,System.Int32)">
+            <summary>
+            Write an enumerated value.
+            </summary>
+            <param name="v">The enumerator.</param>
+            <param name="limit">The number of enumerators in the definition.</param>
+        </member>
+        <member name="M:Ice.OutputStream.writeException(Ice.UserException)">
+            <summary>
+            Writes a user exception to the stream.
+            </summary>
+            <param name="ex">The user exception to write.</param>
+        </member>
+        <member name="M:Ice.OutputStream.startObject(Ice.SlicedData)">
+            <summary>
+            Marks the start of an Ice object.
+            </summary>
+            <param name="slicedData">Preserved slices for this object, or null.</param>
+        </member>
+        <member name="M:Ice.OutputStream.endObject">
+            <summary>
+            Marks the end of an Ice object.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.startException(Ice.SlicedData)">
+            <summary>
+            Marks the start of a user exception.
+            </summary>
+            <param name="slicedData">Preserved slices for this object, or null.</param>
+        </member>
+        <member name="M:Ice.OutputStream.endException">
+            <summary>
+            Marks the end of a user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.startSlice(System.String,System.Int32,System.Boolean)">
+            <summary>
+            Marks the start of a new slice for an Ice object or user exception.
+            </summary>
+            <param name="typeId">The Slice type ID corresponding to this slice.</param>
+            <param name="compactId">The Slice compact type ID corresponding to this slice.</param>
+            <param name="last">True if this is the last slice, false otherwise.</param>
+        </member>
+        <member name="M:Ice.OutputStream.endSlice">
+            <summary>
+            Marks the end of a slice for an Ice object or user exception.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.startEncapsulation(Ice.EncodingVersion,Ice.FormatType)">
+            <summary>
+            Writes the start of an encapsulation to the stream.
+            </summary>
+            <param name="encoding">The encoding version of the encapsulation.</param>
+            <param name="format">The format to use for encoding objects and user exceptions.</param>
+        </member>
+        <member name="M:Ice.OutputStream.startEncapsulation">
+            <summary>
+            Writes the start of an encapsulation to the stream.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.endEncapsulation">
+            <summary>
+            Ends the previous encapsulation.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.getEncoding">
+            <summary>
+            Determines the current encoding version.
+            </summary>
+            <returns>The encoding version.</returns>
+        </member>
+        <member name="M:Ice.OutputStream.writePendingObjects">
+            <summary>
+            Writes the state of Slice classes whose index was previously
+            written with writeObject to the stream.
+            </summary>
+        </member>
+        <member name="M:Ice.OutputStream.writeOptional(System.Int32,Ice.OptionalFormat)">
+            <summary>
+            Write the header information for an optional value.
+            </summary>
+            <param name="tag">The numeric tag associated with the value.</param>
+            <param name="format">The optional format of the value.</param>
+            <returns>True if the optional should be written, false otherwise.</returns>
+        </member>
+        <member name="M:Ice.OutputStream.pos">
+            <summary>
+            Determines the current position in the stream.
+            </summary>
+            <returns>The current position.</returns>
+        </member>
+        <member name="M:Ice.OutputStream.rewrite(System.Int32,System.Int32)">
+            <summary>
+            Inserts a fixed 32-bit size value into the stream at the given position.
+            </summary>
+            <param name="sz">The 32-bit size value.</param>
+            <param name="pos">The position at which to write the value.</param>
+        </member>
+        <member name="M:Ice.OutputStream.startSize">
+            <summary>
+            Returns the current position and allocates four bytes for a fixed-length (32-bit)
+            size value.
+            </summary>
+            <returns>The current position.</returns>
+        </member>
+        <member name="M:Ice.OutputStream.endSize(System.Int32)">
+            <summary>
+            Computes the amount of data written since the previous call to startSize and
+            writes that value at the saved position.
+            </summary>
+            <param name="pos">The saved position at which to write the size.</param>
+        </member>
+        <member name="M:Ice.OutputStream.finished">
+            <summary>
+            Indicates that the marshaling of a request or reply is finished.
+            </summary>
+            <returns>The byte sequence containing the encoded request or reply.</returns>
+        </member>
+        <member name="M:Ice.OutputStream.reset(System.Boolean)">
+             <summary>
+             Resets this output stream. This method allows the stream to be reused, to avoid creating
+             unnecessary garbage.
+             </summary>
+            
+             <param name="clearBuffer">If true, the stream's internal buffer becomes eligible for
+             garbage collection; if false, the stream's internal buffer is retained, to avoid
+             creating unnecessary garbage. If retained, the internal buffer may be resized to a smaller
+             capacity. Either way, reset resets the stream's writing position to zero.</param>
+        </member>
+        <member name="M:Ice.OutputStream.destroy">
+            <summary>
+            Destroys the stream and its associated resources. The application must call destroy prior
+            to releasing the last reference to a stream; failure to do so may result in resource leaks.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectReader">
+            <summary>
+            Base class for extracting objects from an input stream.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectReader.read(Ice.InputStream)">
+            <summary>
+            Read the object's data members.
+            </summary>
+            <param name="inStream">The input stream to read from.</param>
+        </member>
+        <member name="T:Ice.ObjectWriter">
+            <summary>
+            Base class for writing objects to an output stream.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectWriter.write(Ice.OutputStream)">
+            <summary>
+            Writes the state of this Slice class to an output stream.
+            </summary>
+            <param name="outStream">The stream to write to.</param>
+        </member>
+        <member name="T:Ice.ThreadHookPlugin">
+            <summary>
+            Class to support thread notification hooks. Applications using 
+            thread notification hooks instantiate a ThreadHookPlugin with a
+            thread notification hook  and return the instance from their
+            PluginFactory implementation.
+            </summary>
+        </member>
+        <member name="M:Ice.ThreadHookPlugin.#ctor(Ice.Communicator,Ice.ThreadNotification)">
+            <summary>
+            Installs a custom logger for a communicator.
+            </summary>
+            <param name="communicator">The communicator using the thread notification hook.</param>
+            <param name="threadHook">The thread notification hook for the communicator.</param>
+        </member>
+        <member name="M:Ice.ThreadHookPlugin.initialize">
+            <summary>
+            Called by the Ice run time during communicator initialization. The derived class
+            can override this method to perform any initialization that might be required
+            by the thread notification hook.
+            </summary>
+        </member>
+        <member name="M:Ice.ThreadHookPlugin.destroy">
+            <summary>
+            Called by the Ice run time when the communicator is destroyed. The derived class
+            can override this method to perform any finalization that might be required
+            by thread notification hook.
+            </summary>
+        </member>
+        <member name="T:Ice.TieBase">
+            <summary>
+            Interface for servants using the tie mapping.
+            </summary>
+        </member>
+        <member name="M:Ice.TieBase.ice_delegate">
+            <summary>
+            Returns the delegate for this tie.
+            </summary>
+            <returns>The delegate.</returns>
+        </member>
+        <member name="M:Ice.TieBase.ice_delegate(System.Object)">
+            <summary>
+            Returns the delegate for this tie.
+            </summary>
+            <param name="o">The delegate.</param>
+        </member>
+        <member name="T:Ice.UnknownSlicedObject">
+            <summary>
+            Unknown sliced object holds an instance of unknown type.
+            </summary>
+        </member>
+        <member name="M:Ice.UnknownSlicedObject.#ctor(System.String)">
+            <summary>
+            Instantiates the class for an Ice object having the given Slice type.
+            </summary>
+            <param name="unknownTypeId">The Slice type ID of the unknown object.</param>
+        </member>
+        <member name="M:Ice.UnknownSlicedObject.getUnknownTypeId">
+            <summary>
+            Determine the Slice type ID associated with this object.
+            </summary>
+            <returns>The type ID.</returns>
+        </member>
+        <member name="T:Ice.ThreadNotification">
+            <summary>
+            Interface for thread notification hooks. Applications can derive
+            a class tat implements the start and stop
+            methods to intercept creation and destruction of threads created
+            by the Ice run time.
+            </summary>
+        </member>
+        <member name="M:Ice.ThreadNotification.start">
+            <summary>
+            The Ice run time calls start for each new
+            thread it creates. The call is made by the newly-started thread.
+            </summary>
+        </member>
+        <member name="M:Ice.ThreadNotification.stop">
+            <summary>
+            The Ice run time calls stop before it destroys
+            a thread. The call is made by thread that is about to be
+            destroyed.
+            </summary>
+        </member>
+        <member name="T:Ice.Dispatcher">
+            <summary>
+            A delegate for the dispatcher. The dispatcher is called by the Ice
+            runtime to dispatch servant calls and AMI callbacks.
+            </summary>
+        </member>
+        <member name="T:Ice.CompactIdResolver">
+            <summary>
+            Applications that make use of compact type IDs to conserve space
+            when marshaling class instances, and also use the streaming API to
+            extract such classes, can intercept the translation between compact
+            type IDs and their corresponding string type IDs by installing an
+            instance of CompactIdResolver in InitializationData.
+            </summary>
+        </member>
+        <member name="T:Ice.InitializationData">
+            <summary>
+            A class that encpasulates data to initialize a communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.InitializationData.Clone">
+            <summary>
+            Creates and returns a copy of this object.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.properties">
+            <summary>
+            The properties for the communicator.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.logger">
+            <summary>
+            The logger for the communicator.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.observer">
+            <summary>
+            The communicator observer used by the Ice run-time.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.threadHook">
+            <summary>
+            The thread hook for the communicator.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.dispatcher">
+            <summary>
+            The dispatcher for the communicator.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.compactIdResolver">
+            <summary>
+            The compact type ID resolver.
+            </summary>
+        </member>
+        <member name="F:Ice.InitializationData.batchRequestInterceptor">
+            <summary>
+            The batch request interceptor.
+            </summary>
+        </member>
+        <member name="T:Ice.Util">
+            <summary>
+            Utility methods for the Ice run time.
+            </summary>
+        </member>
+        <member name="M:Ice.Util.createProperties">
+            <summary>
+            Creates a new empty property set.
+            </summary>
+            <returns>A new empty property set.</returns>
+        </member>
+        <member name="M:Ice.Util.createProperties(System.String[]@)">
+            <summary>
+            Creates a property set initialized from an argument vector.
+            </summary>
+            <param name="args">A command-line argument vector, possibly containing
+            options to set properties. If the command-line options include
+            a --Ice.Config option, the corresponding configuration
+            files are parsed. If the same property is set in a configuration
+            file and in the argument vector, the argument vector takes precedence.
+            This method modifies the argument vector by removing any Ice-related options.</param>
+            <returns>A property set initialized with the property settings
+            that were removed from args.</returns>
+        </member>
+        <member name="M:Ice.Util.createProperties(System.String[]@,Ice.Properties)">
+            <summary>
+            Creates a property set initialized from an argument vector.
+            </summary>
+            <param name="args">A command-line argument vector, possibly containing
+            options to set properties. If the command-line options include
+            a --Ice.Config option, the corresponding configuration
+            files are parsed. If the same property is set in a configuration
+            file and in the argument vector, the argument vector takes precedence.
+            This method modifies the argument vector by removing any Ice-related options.</param>
+            <param name="defaults">Default values for the property set. Settings in configuration
+            files and args override these defaults.</param>
+            <returns>A property set initialized with the property settings
+            that were removed from args.</returns>
+        </member>
+        <member name="M:Ice.Util.initialize(System.String[]@)">
+            <summary>
+            Creates a communicator.
+            </summary>
+            <param name="args">A command-line argument vector. Any Ice-related options
+            in this vector are used to intialize the communicator.
+            This method modifies the argument vector by removing any Ice-related options.</param>
+            <returns>The initialized communicator.</returns>
+        </member>
+        <member name="M:Ice.Util.initialize(System.String[]@,Ice.InitializationData)">
+            <summary>
+            Creates a communicator.
+            </summary>
+            <param name="args">A command-line argument vector. Any Ice-related options
+            in this vector are used to intialize the communicator.
+            This method modifies the argument vector by removing any Ice-related options.</param>
+            <param name="initData">Additional intialization data. Property settings in args
+            override property settings in initData.</param>
+            <returns>The initialized communicator.</returns>
+        </member>
+        <member name="M:Ice.Util.initialize(Ice.InitializationData)">
+            <summary>
+            Creates a communicator.
+            </summary>
+            <param name="initData">Additional intialization data.</param>
+            <returns>The initialized communicator.</returns>
+        </member>
+        <member name="M:Ice.Util.initialize">
+            <summary>
+            Creates a communicator using a default configuration.
+            </summary>
+        </member>
+        <member name="M:Ice.Util.stringToIdentity(System.String)">
+            <summary>
+            Converts a string to an object identity.
+            </summary>
+            <param name="s">The string to convert.</param>
+            <returns>The converted object identity.</returns>
+        </member>
+        <member name="M:Ice.Util.identityToString(Ice.Identity)">
+            <summary>
+            Converts an object identity to a string.
+            </summary>
+            <param name="ident">The object identity to convert.</param>
+            <returns>The string representation of the object identity.</returns>
+        </member>
+        <member name="M:Ice.Util.generateUUID">
+            <summary>
+            This method is deprecated. Use System.Guid instead.
+            </summary>
+        </member>
+        <member name="M:Ice.Util.proxyIdentityCompare(Ice.ObjectPrx,Ice.ObjectPrx)">
+            <summary>
+            Compares the object identities of two proxies.
+            </summary>
+            <param name="lhs">A proxy.</param>
+            <param name="rhs">A proxy.</param>
+            <returns>-1 if the identity in lhs compares
+            less than the identity in rhs; 0 if the identities
+            compare equal; 1, otherwise.</returns>
+        </member>
+        <member name="M:Ice.Util.proxyIdentityAndFacetCompare(Ice.ObjectPrx,Ice.ObjectPrx)">
+            <summary>
+            Compares the object identities and facets of two proxies.
+            </summary>
+            <param name="lhs">A proxy.</param>
+            <param name="rhs">A proxy.</param>
+            <returns>-1 if the identity and facet in lhs compare
+            less than the identity and facet in rhs; 0 if the identities
+            and facets compare equal; 1, otherwise.</returns>
+        </member>
+        <member name="M:Ice.Util.createInputStream(Ice.Communicator,System.Byte[])">
+            <summary>
+            Creates an input stream for dynamic invocation and dispatch. The stream uses
+            the communicator's default encoding version. The given data is copied.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <param name="bytes">An encoded request or reply.</param>
+            <returns>The input stream.</returns>
+        </member>
+        <member name="M:Ice.Util.createInputStream(Ice.Communicator,System.Byte[],Ice.EncodingVersion)">
+            <summary>
+            Creates an input stream for dynamic invocation and dispatch. The stream uses
+            the given encoding version.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <param name="bytes">An encoded request or reply.</param>
+            <param name="v">The desired encoding version.</param>
+            <returns>The input stream.</returns>
+        </member>
+        <member name="M:Ice.Util.wrapInputStream(Ice.Communicator,System.Byte[])">
+            <summary>
+            Wraps encoded data with an input stream for dynamic invocation and dispatch.
+            The stream uses the communicator's default encoding version.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <param name="bytes">An encoded request or reply.</param>
+            <returns>The input stream.</returns>
+        </member>
+        <member name="M:Ice.Util.wrapInputStream(Ice.Communicator,System.Byte[],Ice.EncodingVersion)">
+            <summary>
+            Wraps encoded data with an input stream for dynamic invocation and dispatch.
+            The stream uses the given encoding version.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <param name="bytes">An encoded request or reply.</param>
+            <param name="v">The desired encoding version.</param>
+            <returns>The input stream.</returns>
+        </member>
+        <member name="M:Ice.Util.createOutputStream(Ice.Communicator)">
+            <summary>
+            Creates an output stream for dynamic invocation and dispatch. The stream uses
+            the communicator's default encoding version.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <returns>The output stream.</returns>
+        </member>
+        <member name="M:Ice.Util.createOutputStream(Ice.Communicator,Ice.EncodingVersion)">
+            <summary>
+            Creates an output stream for dynamic invocation and dispatch. The stream uses
+            the given encoding version.
+            </summary>
+            <param name="communicator">The communicator for the stream.</param>
+            <param name="v">The desired encoding version.</param>
+            <returns>The output stream.</returns>
+        </member>
+        <member name="M:Ice.Util.getProcessLogger">
+            <summary>
+            Returns the process-wide logger.
+            </summary>
+            <returns>The process-wide logger.</returns>
+        </member>
+        <member name="M:Ice.Util.setProcessLogger(Ice.Logger)">
+            <summary>
+            Changes the process-wide logger.
+            </summary>
+            <param name="logger">The new process-wide logger.</param>
+        </member>
+        <member name="M:Ice.Util.stringVersion">
+            <summary>
+            Returns the Ice version in the form A.B.C, where A indicates the
+            major version, B indicates the minor version, and C indicates the
+            patch level.
+            </summary>
+            <returns>The Ice version.</returns>
+        </member>
+        <member name="M:Ice.Util.intVersion">
+            <summary>
+            Returns the Ice version as an integer in the form A.BB.CC, where A
+            indicates the major version, BB indicates the minor version, and CC
+            indicates the patch level. For example, for Ice 3.3.1, the returned value is 30301.
+            </summary>
+            <returns>The Ice version.</returns>
+        </member>
+        <member name="M:Ice.Util.stringToProtocolVersion(System.String)">
+            <summary>
+            Converts a string to a protocol version.
+            </summary>
+            <param name="version">The string to convert.</param>
+            <returns>The converted protocol version.</returns>
+        </member>
+        <member name="M:Ice.Util.stringToEncodingVersion(System.String)">
+            <summary>
+            Converts a string to an encoding version.
+            </summary>
+            <param name="version">The string to convert.</param>
+            <returns>The converted object identity.</returns>
+        </member>
+        <member name="M:Ice.Util.protocolVersionToString(Ice.ProtocolVersion)">
+            <summary>
+            Converts a protocol version to a string.
+            </summary>
+            <param name="v">The protocol version to convert.</param>
+            <returns>The converted string.</returns>
+        </member>
+        <member name="M:Ice.Util.encodingVersionToString(Ice.EncodingVersion)">
+            <summary>
+            Converts an encoding version to a string.
+            </summary>
+            <param name="v">The encoding version to convert.</param>
+            <returns>The converted string.</returns>
+        </member>
+        <member name="M:Ice.ConnectionCallback.heartbeat(Ice.Connection)">
+            <summary>
+            This method is called by the the connection when a heartbeat is
+            received from the peer.
+            </summary>
+        </member>
+        <member name="M:Ice.ConnectionCallback.closed(Ice.Connection)">
+            <summary>
+            This method is called by the the connection when the connection
+            is closed.
+            </summary>
+        </member>
+        <member name="T:Ice.InitializationException">
+            <summary>
+            This exception is raised when a failure occurs during initialization.
+            </summary>
+        </member>
+        <member name="T:Ice.PluginInitializationException">
+            <summary>
+            This exception indicates that a failure occurred while initializing
+            a plug-in.
+            </summary>
+        </member>
+        <member name="T:Ice.CollocationOptimizationException">
+             <summary>
+             This exception is raised if a feature is requested that is not
+             supported with collocation optimization.
+            
+             <para>this exception isn't used anymore by the Ice runtime</para>
+            
+             </summary>
+        </member>
+        <member name="T:Ice.AlreadyRegisteredException">
+            <summary>
+            An attempt was made to register something more than once with
+            the Ice run time.
+            This exception is raised if an attempt is made to register a
+            servant, servant locator, facet, object factory, plug-in, object
+            adapter, object, or user exception factory more than once for the
+            same ID.
+            </summary>
+        </member>
+        <member name="T:Ice.NotRegisteredException">
+            <summary>
+            An attempt was made to find or deregister something that is not
+            registered with the Ice run time or Ice locator.
+            This exception is raised if an attempt is made to remove a servant,
+            servant locator, facet, object factory, plug-in, object adapter,
+            object, or user exception factory that is not currently registered.
+            
+            It's also raised if the Ice locator can't find an object or object
+            adapter when resolving an indirect proxy or when an object adapter
+            is activated.
+            </summary>
+        </member>
+        <member name="T:Ice.TwowayOnlyException">
+            <summary>
+            The operation can only be invoked with a twoway request.
+            This exception is raised if an attempt is made to invoke an
+            operation with ice_oneway, ice_batchOneway, ice_datagram,
+            or ice_batchDatagram and the operation has a return value,
+            out-parameters, or an exception specification.
+            </summary>
+        </member>
+        <member name="T:Ice.CloneNotImplementedException">
+            <summary>
+            An attempt was made to clone a class that does not support
+            cloning.
+            This exception is raised if ice_clone is called on
+            a class that is derived from an abstract Slice class (that is,
+            a class containing operations), and the derived class does not
+            provide an implementation of the ice_clone operation (C++ only).
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownException">
+            <summary>
+            This exception is raised if an operation call on a server raises an
+            unknown exception.
+            For example, for C++, this exception is raised
+            if the server throws a C++ exception that is not directly or
+            indirectly derived from Ice::LocalException or
+            Ice::UserException.
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownLocalException">
+            <summary>
+            This exception is raised if an operation call on a server raises a
+            local exception.
+            Because local exceptions are not transmitted by
+            the Ice protocol, the client receives all local exceptions raised
+            by the server as UnknownLocalException. The only exception to this
+            rule are all exceptions derived from RequestFailedException,
+            which are transmitted by the Ice protocol even though they are
+            declared local.
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownUserException">
+            <summary>
+            An operation raised an incorrect user exception.
+            This exception is raised if an operation raises a
+            user exception that is not declared in the exception's
+            throws clause. Such undeclared exceptions are
+            not transmitted from the server to the client by the Ice
+            protocol, but instead the client just gets an
+            UnknownUserException. This is necessary in order to not violate
+            the contract established by an operation's signature: Only local
+            exceptions and user exceptions declared in the
+            throws clause can be raised.
+            </summary>
+        </member>
+        <member name="T:Ice.VersionMismatchException">
+            <summary>
+            This exception is raised if the Ice library version does not match
+            the version in the Ice header files.
+            </summary>
+        </member>
+        <member name="T:Ice.CommunicatorDestroyedException">
+            <summary>
+            This exception is raised if the Communicator has been destroyed.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectAdapterDeactivatedException">
+            <summary>
+            This exception is raised if an attempt is made to use a deactivated
+            ObjectAdapter.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectAdapterIdInUseException">
+            <summary>
+            This exception is raised if an ObjectAdapter cannot be activated.
+            This happens if the Locator detects another active ObjectAdapter with
+            the same adapter id.
+            </summary>
+        </member>
+        <member name="T:Ice.NoEndpointException">
+            <summary>
+            This exception is raised if no suitable endpoint is available.
+            </summary>
+        </member>
+        <member name="T:Ice.EndpointParseException">
+            <summary>
+            This exception is raised if there was an error while parsing an
+            endpoint.
+            </summary>
+        </member>
+        <member name="T:Ice.EndpointSelectionTypeParseException">
+            <summary>
+            This exception is raised if there was an error while parsing an
+            endpoint selection type.
+            </summary>
+        </member>
+        <member name="T:Ice.VersionParseException">
+            <summary>
+            This exception is raised if there was an error while parsing a
+            version.
+            </summary>
+        </member>
+        <member name="T:Ice.IdentityParseException">
+            <summary>
+            This exception is raised if there was an error while parsing a
+            stringified identity.
+            </summary>
+        </member>
+        <member name="T:Ice.ProxyParseException">
+            <summary>
+            This exception is raised if there was an error while parsing a
+            stringified proxy.
+            </summary>
+        </member>
+        <member name="T:Ice.IllegalIdentityException">
+            <summary>
+            This exception is raised if an illegal identity is encountered.
+            </summary>
+        </member>
+        <member name="T:Ice.IllegalServantException">
+            <summary>
+            This exception is raised to reject an illegal servant (typically
+            a null servant)
+            
+            </summary>
+        </member>
+        <member name="T:Ice.RequestFailedException">
+            <summary>
+            This exception is raised if a request failed.
+            This exception, and
+            all exceptions derived from RequestFailedException, are
+            transmitted by the Ice protocol, even though they are declared
+            local.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectNotExistException">
+            <summary>
+            This exception is raised if an object does not exist on the server,
+            that is, if no facets with the given identity exist.
+            </summary>
+        </member>
+        <member name="T:Ice.FacetNotExistException">
+            <summary>
+            This exception is raised if no facet with the given name exists,
+            but at least one facet with the given identity exists.
+            </summary>
+        </member>
+        <member name="T:Ice.OperationNotExistException">
+            <summary>
+            This exception is raised if an operation for a given object does
+            not exist on the server.
+            Typically this is caused by either the
+            client or the server using an outdated Slice specification.
+            </summary>
+        </member>
+        <member name="T:Ice.SyscallException">
+            <summary>
+            This exception is raised if a system error occurred in the server
+            or client process.
+            There are many possible causes for such a system
+            exception. For details on the cause, SyscallException.error
+            should be inspected.
+            </summary>
+        </member>
+        <member name="T:Ice.SocketException">
+            <summary>
+            This exception indicates socket errors.
+            </summary>
+        </member>
+        <member name="T:Ice.FileException">
+            <summary>
+            This exception indicates file errors.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectFailedException">
+            <summary>
+            This exception indicates connection failures.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectionRefusedException">
+            <summary>
+            This exception indicates a connection failure for which
+            the server host actively refuses a connection.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectionLostException">
+            <summary>
+            This exception indicates a lost connection.
+            </summary>
+        </member>
+        <member name="T:Ice.DNSException">
+            <summary>
+            This exception indicates a DNS problem.
+            For details on the cause,
+            DNSException.error should be inspected.
+            </summary>
+        </member>
+        <member name="T:Ice.OperationInterruptedException">
+            <summary>
+            This exception indicates a request was interrupted.
+            </summary>
+        </member>
+        <member name="T:Ice.TimeoutException">
+            <summary>
+            This exception indicates a timeout condition.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectTimeoutException">
+            <summary>
+            This exception indicates a connection establishment timeout condition.
+            </summary>
+        </member>
+        <member name="T:Ice.CloseTimeoutException">
+            <summary>
+            This exception indicates a connection closure timeout condition.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectionTimeoutException">
+            <summary>
+            This exception indicates that a connection has been shut down because it has been
+            idle for some time.
+            </summary>
+        </member>
+        <member name="T:Ice.InvocationTimeoutException">
+            <summary>
+            This exception indicates that an invocation failed because it timed
+            out.
+            </summary>
+        </member>
+        <member name="T:Ice.InvocationCanceledException">
+            <summary>
+            This exception indicates that an asynchronous invocation failed
+            because it was canceled explicitly by the user using the
+            Ice::AsyncResult::cancel method.
+            </summary>
+        </member>
+        <member name="T:Ice.ProtocolException">
+            <summary>
+            A generic exception base for all kinds of protocol error
+            conditions.
+            </summary>
+        </member>
+        <member name="T:Ice.BadMagicException">
+            <summary>
+            This exception indicates that a message did not start with the expected
+            magic number ('I', 'c', 'e', 'P').
+            </summary>
+        </member>
+        <member name="T:Ice.UnsupportedProtocolException">
+            <summary>
+            This exception indicates an unsupported protocol version.
+            </summary>
+        </member>
+        <member name="T:Ice.UnsupportedEncodingException">
+            <summary>
+            This exception indicates an unsupported data encoding version.
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownMessageException">
+            <summary>
+            This exception indicates that an unknown protocol message has been received.
+            </summary>
+        </member>
+        <member name="T:Ice.ConnectionNotValidatedException">
+            <summary>
+            This exception is raised if a message is received over a connection
+            that is not yet validated.
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownRequestIdException">
+            <summary>
+            This exception indicates that a response for an unknown request ID has been
+            received.
+            </summary>
+        </member>
+        <member name="T:Ice.UnknownReplyStatusException">
+            <summary>
+            This exception indicates that an unknown reply status has been received.
+            </summary>
+        </member>
+        <member name="T:Ice.CloseConnectionException">
+            <summary>
+            This exception indicates that the connection has been gracefully shut down by the
+            server.
+            The operation call that caused this exception has not been
+            executed by the server. In most cases you will not get this
+            exception, because the client will automatically retry the
+            operation call in case the server shut down the connection. However,
+            if upon retry the server shuts down the connection again, and the
+            retry limit has been reached, then this exception is propagated to
+            the application code.
+            </summary>
+        </member>
+        <member name="T:Ice.ForcedCloseConnectionException">
+            <summary>
+            This exception is raised by an operation call if the application
+            forcefully closes the connection Connection.close.
+            </summary>
+        </member>
+        <member name="T:Ice.IllegalMessageSizeException">
+            <summary>
+            This exception indicates that a message size is less
+            than the minimum required size.
+            </summary>
+        </member>
+        <member name="T:Ice.CompressionException">
+            <summary>
+            This exception indicates a problem with compressing or uncompressing data.
+            </summary>
+        </member>
+        <member name="T:Ice.DatagramLimitException">
+            <summary>
+            A datagram exceeds the configured size.
+            This exception is raised if a datagram exceeds the configured send or receive buffer
+            size, or exceeds the maximum payload size of a UDP packet (65507 bytes).
+            </summary>
+        </member>
+        <member name="T:Ice.MarshalException">
+            <summary>
+            This exception is raised for errors during marshaling or unmarshaling data.
+            </summary>
+        </member>
+        <member name="T:Ice.ProxyUnmarshalException">
+            <summary>
+            This exception is raised if inconsistent data is received while unmarshaling a proxy.
+            </summary>
+        </member>
+        <member name="T:Ice.UnmarshalOutOfBoundsException">
+            <summary>
+            This exception is raised if an out-of-bounds condition occurs during unmarshaling.
+            </summary>
+        </member>
+        <member name="T:Ice.NoObjectFactoryException">
+            <summary>
+            This exception is raised if no suitable object factory was found during
+            unmarshaling of a Slice class instance.
+            </summary>
+        </member>
+        <member name="T:Ice.UnexpectedObjectException">
+            <summary>
+            This exception is raised if the type of an unmarshaled Slice class instance does
+            not match its expected type.
+            This can happen if client and server are compiled with mismatched Slice
+            definitions or if a class of the wrong type is passed as a parameter
+            or return value using dynamic invocation. This exception can also be
+            raised if IceStorm is used to send Slice class instances and
+            an operation is subscribed to the wrong topic.
+            </summary>
+        </member>
+        <member name="T:Ice.MemoryLimitException">
+            <summary>
+            This exception is raised when Ice receives a request or reply
+            message whose size exceeds the limit specified by the
+            Ice.MessageSizeMax property.
+            </summary>
+        </member>
+        <member name="T:Ice.StringConversionException">
+            <summary>
+            This exception is raised when a string conversion to or from UTF-8
+            fails during marshaling or unmarshaling.
+            </summary>
+        </member>
+        <member name="T:Ice.EncapsulationException">
+            <summary>
+            This exception indicates a malformed data encapsulation.
+            </summary>
+        </member>
+        <member name="T:Ice.FeatureNotSupportedException">
+            <summary>
+            This exception is raised if an unsupported feature is used.
+            The
+            unsupported feature string contains the name of the unsupported
+            feature
+            </summary>
+        </member>
+        <member name="T:Ice.SecurityException">
+            <summary>
+            This exception indicates a failure in a security subsystem,
+            such as the IceSSL plug-in.
+            </summary>
+        </member>
+        <member name="T:Ice.FixedProxyException">
+            <summary>
+            This exception indicates that an attempt has been made to
+            change the connection properties of a fixed proxy.
+            </summary>
+        </member>
+        <member name="T:Ice.ResponseSentException">
+            <summary>
+            Indicates that the response to a request has already been sent;
+            re-dispatching such a request is not possible.
+            </summary>
+        </member>
+        <member name="T:Ice.AdapterNotFoundException">
+            <summary>
+            This exception is raised if an adapter cannot be found.
+            </summary>
+        </member>
+        <member name="T:Ice.InvalidReplicaGroupIdException">
+            <summary>
+            This exception is raised if the replica group provided by the
+            server is invalid.
+            </summary>
+        </member>
+        <member name="T:Ice.AdapterAlreadyActiveException">
+            <summary>
+            This exception is raised if a server tries to set endpoints for
+            an adapter that is already active.
+            </summary>
+        </member>
+        <member name="T:Ice.ObjectNotFoundException">
+            <summary>
+            This exception is raised if an object cannot be found.
+            </summary>
+        </member>
+        <member name="T:Ice.ServerNotFoundException">
+            <summary>
+            This exception is raised if a server cannot be found.
+            </summary>
+        </member>
+        <member name="T:Ice.LocatorOperations_">
+            <summary>
+            The Ice locator interface.
+            This interface is used by clients to
+            lookup adapters and objects. It is also used by servers to get the
+            locator registry proxy.
+            
+            The Locator interface is intended to be used by
+            Ice internals and by locator implementations. Regular user code
+            should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorOperations_.findObjectById_async(Ice.AMD_Locator_findObjectById,Ice.Identity,Ice.Current)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The identity.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorOperations_.findAdapterById_async(Ice.AMD_Locator_findAdapterById,System.String,Ice.Current)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorOperations_.getRegistry(Ice.Current)">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <returns>The locator registry.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LocatorOperationsNC_">
+            <summary>
+            The Ice locator interface.
+            This interface is used by clients to
+            lookup adapters and objects. It is also used by servers to get the
+            locator registry proxy.
+            
+            The Locator interface is intended to be used by
+            Ice internals and by locator implementations. Regular user code
+            should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorOperationsNC_.findObjectById_async(Ice.AMD_Locator_findObjectById,Ice.Identity)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The identity.
+            
+            </param>
+        </member>
+        <member name="M:Ice.LocatorOperationsNC_.findAdapterById_async(Ice.AMD_Locator_findAdapterById,System.String)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The adapter id.
+            
+            </param>
+        </member>
+        <member name="M:Ice.LocatorOperationsNC_.getRegistry">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <returns>The locator registry.</returns>
+        </member>
+        <member name="T:Ice.LocatorRegistryOperations_">
+            <summary>
+            The Ice locator registry interface.
+            This interface is used by
+            servers to register adapter endpoints with the locator.
+            
+             The LocatorRegistry interface is intended to be used
+            by Ice internals and by locator implementations. Regular user
+            code should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperations_.setAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setAdapterDirectProxy,System.String,Ice.ObjectPrx,Ice.Current)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperations_.setReplicatedAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setReplicatedAdapterDirectProxy,System.String,System.String,Ice.ObjectPrx,Ice.Current)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperations_.setServerProcessProxy_async(Ice.AMD_LocatorRegistry_setServerProcessProxy,System.String,Ice.ProcessPrx,Ice.Current)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LocatorRegistryOperationsNC_">
+            <summary>
+            The Ice locator registry interface.
+            This interface is used by
+            servers to register adapter endpoints with the locator.
+            
+             The LocatorRegistry interface is intended to be used
+            by Ice internals and by locator implementations. Regular user
+            code should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperationsNC_.setAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setAdapterDirectProxy,System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperationsNC_.setReplicatedAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setReplicatedAdapterDirectProxy,System.String,System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+        </member>
+        <member name="M:Ice.LocatorRegistryOperationsNC_.setServerProcessProxy_async(Ice.AMD_LocatorRegistry_setServerProcessProxy,System.String,Ice.ProcessPrx)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="cb__">The callback object for the operation.</param>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+        </member>
+        <member name="T:Ice.LocatorFinderOperations_">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Locator interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/LocatorFinder'. This allows clients
+            to retrieve the locator proxy with just the endpoint information of
+            the service.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorFinderOperations_.getLocator(Ice.Current)">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The locator proxy.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LocatorFinderOperationsNC_">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Locator interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/LocatorFinder'. This allows clients
+            to retrieve the locator proxy with just the endpoint information of
+            the service.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorFinderOperationsNC_.getLocator">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The locator proxy.</returns>
+        </member>
+        <member name="T:Ice.LocatorPrx">
+            <summary>
+            The Ice locator interface.
+            This interface is used by clients to
+            lookup adapters and objects. It is also used by servers to get the
+            locator registry proxy.
+            
+            The Locator interface is intended to be used by
+            Ice internals and by locator implementations. Regular user code
+            should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorPrx.findObjectById(Ice.Identity)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <returns>The proxy, or null if the object is not active.
+            
+            </returns>
+            <exception name="ObjectNotFoundException">Raised if the object cannot
+            be found.</exception>
+        </member>
+        <member name="M:Ice.LocatorPrx.findObjectById(Ice.Identity,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <returns>The proxy, or null if the object is not active.
+            
+            </returns>
+            <exception name="ObjectNotFoundException">Raised if the object cannot
+            be found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findObjectById(Ice.Identity)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findObjectById(Ice.Identity,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findObjectById(Ice.Identity,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findObjectById(Ice.Identity,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="id">The identity.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.end_findObjectById(Ice.AsyncResult)">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The proxy, or null if the object is not active.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.findAdapterById(System.String)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <returns>The adapter proxy, or null if the adapter is not active.
+            
+            </returns>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot be
+            found.</exception>
+        </member>
+        <member name="M:Ice.LocatorPrx.findAdapterById(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <returns>The adapter proxy, or null if the adapter is not active.
+            
+            </returns>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findAdapterById(System.String)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findAdapterById(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findAdapterById(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_findAdapterById(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.end_findAdapterById(Ice.AsyncResult)">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The adapter proxy, or null if the adapter is not active.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.getRegistry">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <returns>The locator registry.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.getRegistry(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <returns>The locator registry.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_getRegistry">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_getRegistry(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_getRegistry(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.begin_getRegistry(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorPrx.end_getRegistry(Ice.AsyncResult)">
+            <summary>
+            Get the locator registry.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The locator registry.</returns>
+        </member>
+        <member name="T:Ice.LocatorRegistryPrx">
+            <summary>
+            The Ice locator registry interface.
+            This interface is used by
+            servers to register adapter endpoints with the locator.
+            
+             The LocatorRegistry interface is intended to be used
+            by Ice internals and by locator implementations. Regular user
+            code should not attempt to use any functionality of this interface
+            directly.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setAdapterDirectProxy(System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot
+            be found, or if the locator only allows
+            registered adapters to set their active proxy and the
+            adapter is not registered with the locator.
+            
+            </exception>
+            <exception name="AdapterAlreadyActiveException">Raised if an adapter with the same
+            id is already active.</exception>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setAdapterDirectProxy(System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot
+            be found, or if the locator only allows
+            registered adapters to set their active proxy and the
+            adapter is not registered with the locator.
+            
+            </exception>
+            <exception name="AdapterAlreadyActiveException">Raised if an adapter with the same
+            id is already active.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setAdapterDirectProxy(System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setAdapterDirectProxy(System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setAdapterDirectProxy(System.String,Ice.ObjectPrx,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setAdapterDirectProxy(System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="id">The adapter id.
+            
+            </param>
+            <param name="proxy">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.end_setAdapterDirectProxy(Ice.AsyncResult)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot
+            be found, or if the locator only allows registered adapters to
+            set their active proxy and the adapter is not registered with
+            the locator.
+            
+            </exception>
+            <exception name="AdapterAlreadyActiveException">Raised if an adapter with the same
+            id is already active.
+            
+            </exception>
+            <exception name="InvalidReplicaGroupIdException">Raised if the given
+            replica group doesn't match the one registered with the
+            locator registry for this object adapter.</exception>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <exception name="AdapterNotFoundException">Raised if the adapter cannot
+            be found, or if the locator only allows registered adapters to
+            set their active proxy and the adapter is not registered with
+            the locator.
+            
+            </exception>
+            <exception name="AdapterAlreadyActiveException">Raised if an adapter with the same
+            id is already active.
+            
+            </exception>
+            <exception name="InvalidReplicaGroupIdException">Raised if the given
+            replica group doesn't match the one registered with the
+            locator registry for this object adapter.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setReplicatedAdapterDirectProxy(System.String,System.String,Ice.ObjectPrx,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="adapterId">The adapter id.
+            
+            </param>
+            <param name="replicaGroupId">The replica group id.
+            
+            </param>
+            <param name="p">The adapter proxy (a dummy direct proxy created
+            by the adapter). The direct proxy contains the adapter
+            endpoints.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.end_setReplicatedAdapterDirectProxy(Ice.AsyncResult)">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setServerProcessProxy(System.String,Ice.ProcessPrx)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <exception name="ServerNotFoundException">Raised if the server cannot
+            be found.</exception>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.setServerProcessProxy(System.String,Ice.ProcessPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <exception name="ServerNotFoundException">Raised if the server cannot
+            be found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setServerProcessProxy(System.String,Ice.ProcessPrx)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setServerProcessProxy(System.String,Ice.ProcessPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setServerProcessProxy(System.String,Ice.ProcessPrx,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.begin_setServerProcessProxy(System.String,Ice.ProcessPrx,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="id">The server id.
+            
+            </param>
+            <param name="proxy">The process proxy.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorRegistryPrx.end_setServerProcessProxy(Ice.AsyncResult)">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LocatorFinderPrx">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Locator interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/LocatorFinder'. This allows clients
+            to retrieve the locator proxy with just the endpoint information of
+            the service.
+            </summary>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.getLocator">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The locator proxy.</returns>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.getLocator(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The locator proxy.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.begin_getLocator">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.begin_getLocator(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.begin_getLocator(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.begin_getLocator(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LocatorFinderPrx.end_getLocator(Ice.AsyncResult)">
+            <summary>
+            Get the locator proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The locator proxy.</returns>
+        </member>
+        <member name="T:Ice.AMD_Locator_findObjectById">
+            <summary>
+            Find an object by identity and return a proxy that contains
+            the adapter ID or endpoints which can be used to access the
+            object.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_Locator_findObjectById.ice_response(Ice.ObjectPrx)">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+            <param name="ret__">(return value) The proxy, or null if the object is not active.
+            
+            </param>
+        </member>
+        <member name="T:Ice.AMD_Locator_findAdapterById">
+            <summary>
+            Find an adapter by id and return a proxy that contains
+            its endpoints.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_Locator_findAdapterById.ice_response(Ice.ObjectPrx)">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+            <param name="ret__">(return value) The adapter proxy, or null if the adapter is not active.
+            
+            </param>
+        </member>
+        <member name="T:Ice.AMD_LocatorRegistry_setAdapterDirectProxy">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_LocatorRegistry_setAdapterDirectProxy.ice_response">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+        </member>
+        <member name="T:Ice.AMD_LocatorRegistry_setReplicatedAdapterDirectProxy">
+            <summary>
+            Set the adapter endpoints with the locator registry.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_LocatorRegistry_setReplicatedAdapterDirectProxy.ice_response">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+        </member>
+        <member name="T:Ice.AMD_LocatorRegistry_setServerProcessProxy">
+            <summary>
+            Set the process proxy for a server.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_LocatorRegistry_setServerProcessProxy.ice_response">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+        </member>
+        <member name="T:IceMX.UnknownMetricsView">
+            <summary>
+            Raised if a metrics view cannot be found.
+            </summary>
+        </member>
+        <member name="T:IceMX.MetricsPrx">
+            <summary>
+            The base class for metrics.
+            A metrics object represents a
+            collection of measurements associated to a given a system.
+            </summary>
+        </member>
+        <member name="T:IceMX.MetricsAdminPrx">
+            <summary>
+            The metrics administrative facet interface.
+            This interface allows
+            remote administrative clients to access metrics of an application
+            that enabled the Ice administrative facility and configured some
+            metrics views.
+            </summary>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsViewNames(System.String[]@)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="disabledViews">The names of the disabled views.
+            
+            </param>
+            <returns>The name of the enabled views.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsViewNames(System.String[]@,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="disabledViews">The names of the disabled views.
+            
+            </param>
+            <returns>The name of the enabled views.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsViewNames">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsViewNames(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsViewNames(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsViewNames(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_getMetricsViewNames(System.String[]@,Ice.AsyncResult)">
+            <summary>
+            Get the names of enabled and disabled metrics.
+            </summary>
+            <param name="disabledViews">The names of the disabled views.
+            
+            </param>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The name of the enabled views.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.enableMetricsView(System.String)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.enableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_enableMetricsView(System.String)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_enableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_enableMetricsView(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_enableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_enableMetricsView(Ice.AsyncResult)">
+            <summary>
+            Enables a metrics view.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.disableMetricsView(System.String)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.disableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_disableMetricsView(System.String)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_disableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_disableMetricsView(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_disableMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="name">The metrics view name.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_disableMetricsView(Ice.AsyncResult)">
+            <summary>
+            Disable a metrics view.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsView(System.String,System.Int64@)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            returns a dictionnary of metric maps for each metrics class
+            configured with the view. The timestamp allows the client to
+            compute averages which are not dependent of the invocation
+            latency for this operation.
+            
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="timestamp">The local time of the process when the metrics
+            object were retrieved.
+            
+            </param>
+            <returns>The metrics view data.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsView(System.String,System.Int64@,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            returns a dictionnary of metric maps for each metrics class
+            configured with the view. The timestamp allows the client to
+            compute averages which are not dependent of the invocation
+            latency for this operation.
+            
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="timestamp">The local time of the process when the metrics
+            object were retrieved.
+            
+            </param>
+            <returns>The metrics view data.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsView(System.String)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsView(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsView(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_getMetricsView(System.Int64@,Ice.AsyncResult)">
+            <summary>
+            Get the metrics objects for the given metrics view.
+            This
+            </summary>
+            <param name="timestamp">The local time of the process when the metrics
+            object were retrieved.
+            
+            </param>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The metrics view data.
+            
+            </returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMapMetricsFailures(System.String,System.String)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <returns>The metrics failures associated with the map.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMapMetricsFailures(System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <returns>The metrics failures associated with the map.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMapMetricsFailures(System.String,System.String)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMapMetricsFailures(System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMapMetricsFailures(System.String,System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMapMetricsFailures(System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_getMapMetricsFailures(Ice.AsyncResult)">
+            <summary>
+            Get the metrics failures associated with the given view and map.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The metrics failures associated with the map.
+            
+            </returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsFailures(System.String,System.String,System.String)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <returns>The metrics failures associated with the metrics.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.getMetricsFailures(System.String,System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <returns>The metrics failures associated with the metrics.
+            
+            </returns>
+            <exception name="UnknownMetricsView">Raised if the metrics view cannot be
+            found.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsFailures(System.String,System.String,System.String)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsFailures(System.String,System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsFailures(System.String,System.String,System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.begin_getMetricsFailures(System.String,System.String,System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="view">The name of the metrics view.
+            
+            </param>
+            <param name="map">The name of the metrics map.
+            
+            </param>
+            <param name="id">The ID of the metrics.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:IceMX.MetricsAdminPrx.end_getMetricsFailures(Ice.AsyncResult)">
+            <summary>
+            Get the metrics failure associated for the given metrics.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The metrics failures associated with the metrics.
+            
+            </returns>
+        </member>
+        <member name="T:IceMX.ThreadMetricsPrx">
+            <summary>
+            Provides information on the number of threads currently in use and
+            their activity.
+            </summary>
+        </member>
+        <member name="T:IceMX.DispatchMetricsPrx">
+            <summary>
+            Provides information on servant dispatch.
+            </summary>
+        </member>
+        <member name="T:IceMX.ChildInvocationMetricsPrx">
+            <summary>
+            Provides information on child invocations.
+            A child invocation is
+            either remote (sent over an Ice connection) or collocated. An
+            invocation can have multiple child invocation if it is
+            retried. Child invocation metrics are embedded within InvocationMetrics.
+            </summary>
+        </member>
+        <member name="T:IceMX.CollocatedMetricsPrx">
+            <summary>
+            Provides information on invocations that are collocated.
+            Collocated
+            metrics are embedded within InvocationMetrics.
+            </summary>
+        </member>
+        <member name="T:IceMX.RemoteMetricsPrx">
+            <summary>
+            Provides information on invocations that are specifically sent over
+            Ice connections.
+            Remote metrics are embedded within InvocationMetrics.
+            </summary>
+        </member>
+        <member name="T:IceMX.InvocationMetricsPrx">
+            <summary>
+            Provide measurements for proxy invocations.
+            Proxy invocations can
+            either be sent over the wire or be collocated.
+            </summary>
+        </member>
+        <member name="T:IceMX.ConnectionMetricsPrx">
+            <summary>
+            Provides information on the data sent and received over Ice
+            connections.
+            </summary>
+        </member>
+        <member name="M:Ice.ObjectFactory.create(System.String)">
+            <summary>
+            Create a new object for a given object type.
+            The type is the
+            absolute Slice type id, i.e., the id relative to the
+            unnamed top-level Slice module. For example, the absolute
+            Slice type id for interfaces of type Bar in the module
+            Foo is ::Foo::Bar.
+            
+            The leading "::" is required.
+            
+            </summary>
+            <param name="type">The object type.
+            
+            </param>
+            <returns>The object created for the given type, or nil if the
+            factory is unable to create the object.</returns>
+        </member>
+        <member name="M:Ice.ObjectFactory.destroy">
+            <summary>
+            Called when the factory is removed from the communicator, or if
+            the communicator is destroyed.
+            </summary>
+        </member>
+        <member name="T:Ice.ProcessPrx">
+            <summary>
+            An administrative interface for process management.
+            Managed servers must
+            implement this interface.
+            
+            A servant implementing this interface is a potential target
+            for denial-of-service attacks, therefore proper security precautions
+            should be taken. For example, the servant can use a UUID to make its
+            identity harder to guess, and be registered in an object adapter with
+            a secured endpoint.
+            </summary>
+        </member>
+        <member name="M:Ice.ProcessPrx.shutdown">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+        </member>
+        <member name="M:Ice.ProcessPrx.shutdown(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_shutdown">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_shutdown(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_shutdown(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_shutdown(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.end_shutdown(Ice.AsyncResult)">
+            <summary>
+            Initiate a graceful shut-down.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:Ice.ProcessPrx.writeMessage(System.String,System.Int32)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+        </member>
+        <member name="M:Ice.ProcessPrx.writeMessage(System.String,System.Int32,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_writeMessage(System.String,System.Int32)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_writeMessage(System.String,System.Int32,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_writeMessage(System.String,System.Int32,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.begin_writeMessage(System.String,System.Int32,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="message">The message.
+            
+            </param>
+            <param name="fd">1 for stdout, 2 for stderr.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.ProcessPrx.end_writeMessage(Ice.AsyncResult)">
+            <summary>
+            Write a message on the process' stdout or stderr.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="T:Ice.PropertiesAdminPrx">
+            <summary>
+            The PropertiesAdmin interface provides remote access to the properties
+            of a communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.getProperty(System.String)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            string is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.getProperty(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            string is returned.
+            
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>The property value.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getProperty(System.String)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getProperty(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getProperty(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getProperty(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            </summary>
+            <param name="key">The property key.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.end_getProperty(Ice.AsyncResult)">
+            <summary>
+            Get a property by key.
+            If the property is not set, an empty
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The property value.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.getPropertiesForPrefix(System.String)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            prefix is an empty string then all properties are returned.
+            
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>The matching property set.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.getPropertiesForPrefix(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            prefix is an empty string then all properties are returned.
+            
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>The matching property set.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getPropertiesForPrefix(System.String)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getPropertiesForPrefix(System.String,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getPropertiesForPrefix(System.String,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_getPropertiesForPrefix(System.String,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            </summary>
+            <param name="prefix">The prefix to search for (empty string if none).
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.end_getPropertiesForPrefix(Ice.AsyncResult)">
+            <summary>
+            Get all properties whose keys begin with prefix.
+            If
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The matching property set.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.setProperties(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.setProperties(System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_setProperties(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_setProperties(System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_setProperties(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.begin_setProperties(System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="newProperties">Properties to be added, changed, or removed.
+            If an entry in newProperties matches the name of an existing property,
+            that property's value is replaced with the new value. If the new value
+            is an empty string, the property is removed. Any existing properties
+            that are not modified or removed by the entries in newProperties are
+            retained with their original values.</param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.PropertiesAdminPrx.end_setProperties(Ice.AsyncResult)">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="T:Ice.AMD_PropertiesAdmin_setProperties">
+            <summary>
+            Update the communicator's properties with the given property set.
+            </summary>
+        </member>
+        <member name="M:Ice.AMD_PropertiesAdmin_setProperties.ice_response">
+            <summary>
+            ice_response indicates that
+            the operation completed successfully.
+            </summary>
+        </member>
+        <member name="T:Ice.RemoteLoggerOperations_">
+            <summary>
+            The Ice remote logger interface.
+            An application can implement a
+            RemoteLogger to receive the log messages sent to the local Logger
+            of another Ice application.
+            </summary>
+        </member>
+        <member name="M:Ice.RemoteLoggerOperations_.init(System.String,Ice.LogMessage[],Ice.Current)">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.RemoteLoggerOperations_.log(Ice.LogMessage,Ice.Current)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            before init.
+            
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.RemoteLoggerOperationsNC_">
+            <summary>
+            The Ice remote logger interface.
+            An application can implement a
+            RemoteLogger to receive the log messages sent to the local Logger
+            of another Ice application.
+            </summary>
+        </member>
+        <member name="M:Ice.RemoteLoggerOperationsNC_.init(System.String,Ice.LogMessage[])">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+        </member>
+        <member name="M:Ice.RemoteLoggerOperationsNC_.log(Ice.LogMessage)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            before init.
+            
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+        </member>
+        <member name="T:Ice.RemoteLoggerAlreadyAttachedException">
+            <summary>
+            An exception thrown by LoggerAdmin.attachRemoteLogger to report
+            that the provided RemoteLogger was previously attached to this
+            LoggerAdmin.
+            </summary>
+        </member>
+        <member name="T:Ice.RemoteLoggerPrx">
+            <summary>
+            The Ice remote logger interface.
+            An application can implement a
+            RemoteLogger to receive the log messages sent to the local Logger
+            of another Ice application.
+            </summary>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.init(System.String,Ice.LogMessage[])">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.init(System.String,Ice.LogMessage[],System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_init(System.String,Ice.LogMessage[])">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_init(System.String,Ice.LogMessage[],System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_init(System.String,Ice.LogMessage[],Ice.AsyncCallback,System.Object)">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_init(System.String,Ice.LogMessage[],System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger
+            
+            </param>
+            <param name="logMessages">Old log messages generated before "now".
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.end_init(Ice.AsyncResult)">
+            <summary>
+            init is called by LoggerAdmin.attachRemoteLogger when a
+            RemoteLogger proxy is attached.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.log(Ice.LogMessage)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            before init.
+            
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.log(Ice.LogMessage,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            before init.
+            
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_log(Ice.LogMessage)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_log(Ice.LogMessage,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_log(Ice.LogMessage,Ice.AsyncCallback,System.Object)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.begin_log(Ice.LogMessage,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            </summary>
+            <param name="message">The message to log.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RemoteLoggerPrx.end_log(Ice.AsyncResult)">
+            <summary>
+            Log a LogMessage.
+            Note that log may be called by LoggerAdmin
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="T:Ice.LoggerAdminPrx">
+            <summary>
+            The interface of the admin object that allows an Ice application the attach its
+            RemoteLogger to the Logger of this admin object's Ice communicator.
+            </summary>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <exception name="RemoteLoggerAlreadyAttachedException">Raised if this remote logger is already
+            attached to this admin object.</exception>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <exception name="RemoteLoggerAlreadyAttachedException">Raised if this remote logger is already
+            attached to this admin object.</exception>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32,Ice.AsyncCallback,System.Object)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_attachRemoteLogger(Ice.RemoteLoggerPrx,Ice.LogMessageType[],System.String[],System.Int32,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="messageTypes">The list of message types that the remote logger wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that the remote logger wishes to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be provided
+            to RemoteLogger.init. A negative value requests all messages available.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.end_attachRemoteLogger(Ice.AsyncResult)">
+            <summary>
+            attachRemoteLogger is called to attach a RemoteLogger object to
+            the local Logger.
+            attachRemoteLogger calls init on the provided RemoteLogger proxy.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.detachRemoteLogger(Ice.RemoteLoggerPrx)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <returns>True if the provided remote logger proxy was detached, and false otherwise.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.detachRemoteLogger(Ice.RemoteLoggerPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <returns>True if the provided remote logger proxy was detached, and false otherwise.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_detachRemoteLogger(Ice.RemoteLoggerPrx)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_detachRemoteLogger(Ice.RemoteLoggerPrx,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_detachRemoteLogger(Ice.RemoteLoggerPrx,Ice.AsyncCallback,System.Object)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_detachRemoteLogger(Ice.RemoteLoggerPrx,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="prx">A proxy to the remote logger.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.end_detachRemoteLogger(Ice.AsyncResult)">
+            <summary>
+            detachRemoteLogger is called to detach a RemoteLogger object from
+            the local Logger.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>True if the provided remote logger proxy was detached, and false otherwise.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.getLog(Ice.LogMessageType[],System.String[],System.Int32,System.String@)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="prefix">The prefix of the associated local Logger.
+            
+            </param>
+            <returns>The Log messages.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.getLog(Ice.LogMessageType[],System.String[],System.Int32,System.String@,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="prefix">The prefix of the associated local Logger.
+            
+            </param>
+            <returns>The Log messages.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_getLog(Ice.LogMessageType[],System.String[],System.Int32)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_getLog(Ice.LogMessageType[],System.String[],System.Int32,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_getLog(Ice.LogMessageType[],System.String[],System.Int32,Ice.AsyncCallback,System.Object)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.begin_getLog(Ice.LogMessageType[],System.String[],System.Int32,System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="messageTypes">The list of message types that the caller wishes to receive.
+            An empty list means no filtering (send all message types).
+            
+            </param>
+            <param name="traceCategories">The categories of traces that caller wish to receive.
+            This parameter is ignored if messageTypes is not empty and does not include trace.
+            An empty list means no filtering (send all trace categories).
+            
+            </param>
+            <param name="messageMax">The maximum number of log messages (of all types) to be returned.
+            A negative value requests all messages available.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.LoggerAdminPrx.end_getLog(System.String@,Ice.AsyncResult)">
+            <summary>
+            getLog retrieves log messages recently logged.
+            </summary>
+            <param name="prefix">The prefix of the associated local Logger.
+            
+            </param>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The Log messages.</returns>
+        </member>
+        <member name="T:Ice.RouterOperations_">
+            <summary>
+            The Ice router interface.
+            Routers can be set either globally with
+            Communicator.setDefaultRouter, or with ice_router on specific
+            proxies.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterOperations_.getClientProxy(Ice.Current)">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            to the router's endpoints.
+            
+            </summary>
+            <returns>The router's client proxy.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterOperations_.getServerProxy(Ice.Current)">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <returns>The router's server proxy.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterOperations_.addProxies(Ice.ObjectPrx[],Ice.Current)">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <returns>Proxies discarded by the router.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.RouterOperationsNC_">
+            <summary>
+            The Ice router interface.
+            Routers can be set either globally with
+            Communicator.setDefaultRouter, or with ice_router on specific
+            proxies.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterOperationsNC_.getClientProxy">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            to the router's endpoints.
+            
+            </summary>
+            <returns>The router's client proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterOperationsNC_.getServerProxy">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <returns>The router's server proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterOperationsNC_.addProxies(Ice.ObjectPrx[])">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <returns>Proxies discarded by the router.</returns>
+        </member>
+        <member name="T:Ice.RouterFinderOperations_">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Router interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/RouterFinder'. This allows clients to
+            retrieve the router proxy with just the endpoint information of the
+            service.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterFinderOperations_.getRouter(Ice.Current)">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The router proxy.</returns>
+            <param name="current__">The Current object for the invocation.</param>
+        </member>
+        <member name="T:Ice.RouterFinderOperationsNC_">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Router interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/RouterFinder'. This allows clients to
+            retrieve the router proxy with just the endpoint information of the
+            service.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterFinderOperationsNC_.getRouter">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The router proxy.</returns>
+        </member>
+        <member name="T:Ice.RouterPrx">
+            <summary>
+            The Ice router interface.
+            Routers can be set either globally with
+            Communicator.setDefaultRouter, or with ice_router on specific
+            proxies.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterPrx.getClientProxy">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            to the router's endpoints.
+            
+            </summary>
+            <returns>The router's client proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.getClientProxy(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            to the router's endpoints.
+            
+            </summary>
+            <returns>The router's client proxy.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getClientProxy">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getClientProxy(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getClientProxy(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getClientProxy(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.end_getClientProxy(Ice.AsyncResult)">
+            <summary>
+            Get the router's client proxy, i.e., the proxy to use for
+            forwarding requests from the client to the router.
+            If a null proxy is returned, the client will forward requests
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The router's client proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.getServerProxy">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <returns>The router's server proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.getServerProxy(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <returns>The router's server proxy.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getServerProxy">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getServerProxy(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getServerProxy(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_getServerProxy(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.end_getServerProxy(Ice.AsyncResult)">
+            <summary>
+            Get the router's server proxy, i.e., the proxy to use for
+            forwarding requests from the server to the router.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The router's server proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.addProxies(Ice.ObjectPrx[])">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <returns>Proxies discarded by the router.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.addProxies(Ice.ObjectPrx[],System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <returns>Proxies discarded by the router.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_addProxies(Ice.ObjectPrx[])">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_addProxies(Ice.ObjectPrx[],System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_addProxies(Ice.ObjectPrx[],Ice.AsyncCallback,System.Object)">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.begin_addProxies(Ice.ObjectPrx[],System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="proxies">The proxies to add.
+            
+            </param>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterPrx.end_addProxies(Ice.AsyncResult)">
+            <summary>
+            Add new proxy information to the router's routing table.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>Proxies discarded by the router.</returns>
+        </member>
+        <member name="T:Ice.RouterFinderPrx">
+            <summary>
+            This inferface should be implemented by services implementing the
+            Ice::Router interface.
+            It should be advertised through an Ice
+            object with the identity `Ice/RouterFinder'. This allows clients to
+            retrieve the router proxy with just the endpoint information of the
+            service.
+            </summary>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.getRouter">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The router proxy.</returns>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.getRouter(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            
+            </summary>
+            <returns>The router proxy.</returns>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.begin_getRouter">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.begin_getRouter(System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.begin_getRouter(Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.begin_getRouter(System.Collections.Generic.Dictionary{System.String,System.String},Ice.AsyncCallback,System.Object)">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="ctx__">The Context map to send with the invocation.</param>
+            <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
+            <param name="cookie__">Application data to store in the asynchronous result object.</param>
+            <returns>An asynchronous result object.</returns>
+        </member>
+        <member name="M:Ice.RouterFinderPrx.end_getRouter(Ice.AsyncResult)">
+            <summary>
+            Get the router proxy implemented by the process hosting this
+            finder object.
+            The proxy might point to several replicas.
+            </summary>
+            <param name="r__">The asynchronous result object for the invocation.</param>
+            <returns>The router proxy.</returns>
+        </member>
+        <member name="M:Ice.ServantLocator.locate(Ice.Current,System.Object@)">
+            <summary>
+            Called before a request is dispatched if a
+            servant cannot be found in the object adapter's active servant
+            map.
+            Note that the object adapter does not automatically insert
+            the returned servant into its active servant map. This must be
+            done by the servant locator implementation, if this is desired.
+            
+            locate can throw any user exception. If it does, that exception
+            is marshaled back to the client. If the Slice definition for the
+            corresponding operation includes that user exception, the client
+            receives that user exception; otherwise, the client receives
+            UnknownUserException.
+            
+            If locate throws any exception, the Ice run time does not
+            call finished.
+            
+            If you call locate from your own code, you
+            must also call finished when you have finished using the
+            servant, provided that locate returned a non-null servant;
+            otherwise, you will get undefined behavior if you use
+            servant locators such as the Freeze Evictor.
+            
+            </summary>
+            <param name="curr">Information about the current operation for which
+            a servant is required.
+            
+            </param>
+            <param name="cookie">A "cookie" that will be passed to finished.
+            
+            </param>
+            <returns>The located servant, or null if no suitable servant has
+            been found.
+            
+            </returns>
+        </member>
+        <member name="M:Ice.ServantLocator.finished(Ice.Current,Ice.Object,System.Object)">
+            <summary>
+            Called by the object adapter after a request has been
+            made.
+            This operation is only called if locate was called
+            prior to the request and returned a non-null servant. This
+            operation can be used for cleanup purposes after a request.
+            
+            finished can throw any user exception. If it does, that exception
+            is marshaled back to the client. If the Slice definition for the
+            corresponding operation includes that user exception, the client
+            receives that user exception; otherwise, the client receives
+            UnknownUserException.
+            
+            If both the operation and finished throw an exception, the
+            exception thrown by finished is marshaled back to the client.
+            
+            </summary>
+            <param name="curr">Information about the current operation call for
+            which a servant was located by locate.
+            
+            </param>
+            <param name="servant">The servant that was returned by locate.
+            
+            </param>
+            <param name="cookie">The cookie that was returned by locate.
+            
+            </param>
+        </member>
+        <member name="M:Ice.ServantLocator.deactivate(System.String)">
+            <summary>
+            Called when the object adapter in which this servant locator is
+            installed is destroyed.
+            </summary>
+            <param name="category">Indicates for which category the servant locator
+            is being deactivated.
+            
+            </param>
+        </member>
+    </members>
+</doc>

DotNet/library/readme.md

@@ -0,0 +1 @@
+server专用的库放在此目录